import { checkPermission, isAdmin, PERMISSIONS } from '../../utils/permission.js'

Page({
  data: {
    userInfo: {},
    isLoggedIn: false,
    avatarLoadError: false,
    loginAvatarLoadError: false, // 首次登录头像加载错误标记
    showWechatForm: false,
    tempAvatarUrl: '',
    tempNickname: '',
    showDevButtons: true, // 开发模式下显示测试按钮
    hasAdminPermission: false, // 是否有管理员权限
    isSuperAdmin: false, // 是否是超级管理员
    userPermissions: [], // 用户权限列表
    userRole: 'user', // 用户角色
    tapCount: 0, // 头像点击计数
    showWechatAvatarPicker: false, // 微信头像选择器显示状态
    stats: {
      totalOrders: 0,
      pendingOrders: 0,
      activeOrders: 0,
      completedOrders: 0,
      completionRate: 0,
      // 项目统计（备用）
      totalProjects: 0,
      activeProjects: 0,
      completedProjects: 0
    },
    version: '加载中...',
    versionInfo: null, // 完整版本信息
    copySuccess: false,
    returnUrl: '', // 登录后需要返回的页面URL
    hasUpdate: false, // 是否有可用更新
    updateStatus: 'none', // 更新状态：none, checking, downloading, ready, failed

  },

  onLoad(options) {
    console.log('个人中心页面加载，参数:', options)

    // 检查是否有返回URL（从参数或存储中获取）
    let returnUrl = ''
    if (options.returnUrl) {
      returnUrl = decodeURIComponent(options.returnUrl)
      console.log('从参数获取返回URL:', returnUrl)
    } else {
      returnUrl = wx.getStorageSync('loginReturnUrl') || ''
      if (returnUrl) {
        console.log('从存储获取返回URL:', returnUrl)
        // 清除存储的URL，避免重复使用
        wx.removeStorageSync('loginReturnUrl')
      }
    }

    if (returnUrl) {
      this.setData({ returnUrl })
    }

    // 检查云开发环境
    this.checkCloudEnvironment()

    this.loadUserInfo()
    this.loadStats()
    this.checkCloudUserInfo()

    // 延迟检查头像设置，确保用户信息已加载
    setTimeout(() => {
      this.checkAvatarSetup()
    }, 1000)

    // 添加页面错误监听，捕获可能未被处理的头像选择错误
    this.setupErrorHandling()

    // 检查用户权限（立即执行一次，然后延迟再执行一次确保准确性）
    this.checkUserPermissions()

    setTimeout(() => {
      this.checkUserPermissions()
    }, 1500)

    // 自动检查更新（静默检查，不显示加载提示）
    setTimeout(() => {
      this.silentCheckUpdate()
    }, 2000)

    // 检查是否有待处理的更新
    this.checkPendingUpdates()

    // 获取服务器版本信息
    this.loadVersionInfo()
  },

  onShow() {
    this.loadUserInfo()
    this.loadStats()

    // 每次显示页面时检查权限（延迟执行，确保云开发环境已初始化）
    setTimeout(() => {
      this.checkUserPermissions()
    }, 500)

    // 同步更新状态
    this.syncUpdateStatus()

    // 同步版本信息（静默更新）
    this.loadVersionInfo(true)
  },

  // 检查用户权限
  async checkUserPermissions() {
    try {
      console.log('🔍 检查用户权限')

      // 获取用户完整权限信息
      const permissionResult = await wx.cloud.callFunction({
        name: 'checkUserPermission',
        data: { permission: 'basic' }
      })

      let userPermissions = ['basic']
      let userRole = 'user'
      let hasAdminPermission = false
      let isSuperAdmin = false

      if (permissionResult.result && permissionResult.result.success) {
        const data = permissionResult.result.data
        let rawPermissions = data.permissions || ['basic']
        userRole = data.role || 'user'

        // 处理权限数据类型问题
        if (typeof rawPermissions === 'string') {
          try {
            // 如果是字符串，尝试解析为数组
            userPermissions = JSON.parse(rawPermissions)
            console.log('🔧 权限数据从字符串转换为数组:', userPermissions)
          } catch (error) {
            console.warn('⚠️ 权限字符串解析失败，使用默认权限:', error)
            userPermissions = ['basic']
          }
        } else if (Array.isArray(rawPermissions)) {
          userPermissions = rawPermissions
        } else {
          console.warn('⚠️ 权限数据类型异常:', typeof rawPermissions, rawPermissions)
          userPermissions = ['basic']
        }

        // 检查是否有管理员权限（admin或super_admin）
        const hasAdminInPermissions = userPermissions.includes('admin')
        const hasSuperAdminInPermissions = userPermissions.includes('super_admin')

        // 如果角色是管理员相关，也应该有管理员权限
        const isAdminRole = userRole === 'admin' || userRole === 'super_admin'

        // 特殊处理：如果角色是super_admin，直接给予管理员权限
        if (userRole === 'super_admin') {
          hasAdminPermission = true
          console.log('🎯 检测到super_admin角色，直接授予管理员权限')
        } else {
          hasAdminPermission = hasAdminInPermissions || hasSuperAdminInPermissions || isAdminRole
        }

        // 检查是否是超级管理员
        isSuperAdmin = hasSuperAdminInPermissions || userRole === 'super_admin'

        console.log('📋 权限详情:', {
          permissions: userPermissions,
          permissionsLength: userPermissions.length,
          permissionsDetail: userPermissions.map((p, i) => `${i}: "${p}"`),
          role: userRole,
          hasAdmin: hasAdminInPermissions,
          hasSuperAdmin: hasSuperAdminInPermissions,
          isAdminRole: isAdminRole,
          finalAdminPermission: hasAdminPermission,
          isSuperAdmin: isSuperAdmin,
          superAdminCheck: `${hasSuperAdminInPermissions} || ${userRole === 'super_admin'} = ${isSuperAdmin}`
        })

        // 详细打印每个权限
        console.log('🔍 权限数组详细分析:')
        userPermissions.forEach((permission, index) => {
          console.log(`  [${index}] "${permission}" (长度: ${permission.length}, 类型: ${typeof permission})`)
          console.log(`      是否为admin: ${permission === 'admin'}`)
          console.log(`      是否为super_admin: ${permission === 'super_admin'}`)
        })
      } else {
        console.warn('⚠️ 权限查询失败:', permissionResult.result?.error)
        // 设置默认值
        isSuperAdmin = false
      }

      // 检查权限是否发生变化
      const previousAdminPermission = this.data.hasAdminPermission
      const previousRole = this.data.userRole
      const previousSuperAdmin = this.data.isSuperAdmin

      this.setData({
        hasAdminPermission: hasAdminPermission,
        isSuperAdmin: isSuperAdmin,
        userPermissions: userPermissions,
        userRole: userRole
      })

      // 如果权限发生变化，显示提示
      if (previousAdminPermission !== hasAdminPermission) {
        if (hasAdminPermission) {
          console.log('🎉 用户获得管理员权限')
        } else {
          console.log('⚠️ 用户失去管理员权限')
        }
      }

      if (previousSuperAdmin !== isSuperAdmin) {
        if (isSuperAdmin) {
          console.log('👑 用户获得超级管理员权限')
        } else {
          console.log('⚠️ 用户失去超级管理员权限')
        }
      }

      if (previousRole !== userRole && userRole !== 'user') {
        console.log('🔄 用户角色变更:', previousRole, '->', userRole)
      }

      console.log('✅ 用户权限检查完成:', {
        hasAdminPermission,
        isSuperAdmin,
        userPermissions,
        userRole,
        adminMenuVisible: hasAdminPermission,
        devToolsVisible: isSuperAdmin
      })

      // 强制刷新页面数据以确保UI更新
      this.setData({
        hasAdminPermission: hasAdminPermission,
        isSuperAdmin: isSuperAdmin,
        userPermissions: userPermissions,
        userRole: userRole
      })

    } catch (error) {
      console.error('❌ 权限检查失败:', error)
      this.setData({
        hasAdminPermission: false,
        userPermissions: ['basic'],
        userRole: 'user'
      })
    }
  },

  // 设置错误处理
  setupErrorHandling() {
    // 监听页面错误
    const originalError = console.error
    console.error = (...args) => {
      // 检查是否是头像选择相关的错误
      const errorStr = args.join(' ')
      if (errorStr.includes('chooseAvatar') && errorStr.includes('ENOENT')) {
        console.log('🔍 检测到头像选择ENOENT错误，显示友好提示')
        
        // 延迟显示提示，避免与其他提示冲突
        setTimeout(() => {
          if (this.data.showWechatForm) {
            this.showDeveloperToolTip()
          }
        }, 1000)
      }
      
      // 调用原始的console.error
      originalError.apply(console, args)
    }
  },

  // 检查云开发环境
  checkCloudEnvironment() {
    const app = getApp()

    console.log('🔍 检查云开发环境状态')
    console.log('- 云开发环境就绪:', app.globalData.cloudEnvReady)
    console.log('- wx.cloud 对象:', !!wx.cloud)

    if (!wx.cloud) {
      console.error('❌ wx.cloud 对象不存在')
      wx.showModal({
        title: '云开发初始化失败',
        content: '请使用 2.2.3 或以上的基础库以使用云能力',
        showCancel: false
      })
      return false
    }

    if (!app.globalData.cloudEnvReady) {
      console.error('❌ 云开发环境未就绪')

      // 尝试重新初始化云开发
      const envId = 'cloud1-8gge1454b08b1f51'
      try {
        wx.cloud.init({
          env: envId,
          traceUser: true,
        })
        app.globalData.cloudEnvReady = true
        console.log('✅ 云开发环境重新初始化成功')
        return true
      } catch (error) {
        console.error('❌ 云开发环境重新初始化失败:', error)
        wx.showModal({
          title: '云开发环境错误',
          content: '云开发环境初始化失败，头像上传功能可能无法正常使用',
          showCancel: false
        })
        return false
      }
    }

    console.log('✅ 云开发环境检查通过')
    return true
  },

  // 加载用户信息
  async loadUserInfo() {
    const userInfo = wx.getStorageSync('userInfo') || {}
    const isLoggedIn = wx.getStorageSync('isLoggedIn') || false

    console.log('📱 个人中心加载用户信息:', userInfo)
    console.log('🔐 当前登录状态:', isLoggedIn)
    console.log('👤 用户昵称:', userInfo.nickName)
    console.log('🆔 用户ID:', userInfo.numericId)

    // 如果本地显示已登录，验证云端用户是否存在且信息完整
    if (isLoggedIn && userInfo && userInfo.nickName) {
      try {
        const result = await wx.cloud.callFunction({
          name: 'userManager',
          data: {
            action: 'getUserInfo'
          }
        })

        if (!result.result.success || !result.result.userInfo ||
            !result.result.userInfo.nickName || !result.result.userInfo.numericId) {
          // 云端用户不存在或信息不完整，清除本地登录状态
          console.log('⚠️ 云端用户不存在或信息不完整，清除本地登录状态')

          wx.removeStorageSync('userInfo')
          wx.removeStorageSync('isLoggedIn')

          this.setData({
            userInfo: {},
            isLoggedIn: false,
            avatarLoadError: false
          })

          // 显示提示信息
          wx.showToast({
            title: '用户信息已过期，请重新登录',
            icon: 'none',
            duration: 2000
          })

          return
        } else {
          // 云端用户存在且完整，同步最新信息到本地
          const cloudUser = result.result.userInfo
          if (JSON.stringify(userInfo) !== JSON.stringify(cloudUser)) {
            console.log('🔄 同步云端最新用户信息到本地')
            wx.setStorageSync('userInfo', cloudUser)
            this.setData({
              userInfo: cloudUser,
              isLoggedIn: true,
              avatarLoadError: false
            })
            return
          }
        }
      } catch (error) {
        console.error('❌ 验证云端用户失败:', error)
        // 网络错误等情况，保持本地状态
      }
    }

    this.setData({
      userInfo,
      isLoggedIn,
      avatarLoadError: false
    })

    console.log('✅ 个人中心页面数据已更新，isLoggedIn:', this.data.isLoggedIn)
  },

  // 头像加载成功
  onAvatarLoad() {
    console.log('头像加载成功')
    this.setData({
      avatarLoadError: false
    })
  },

  // 头像加载失败
  onAvatarError(e) {
    console.error('头像加载失败:', e.detail)
    this.setData({
      avatarLoadError: true
    })
  },

  // 加载统计数据
  async loadStats() {
    console.log('📊 个人中心开始加载统计数据...')

    try {
      // 使用云函数获取最新的统计数据
      const result = await wx.cloud.callFunction({
        name: 'businessManager',
        data: {
          action: 'getStats'
        }
      })

      if (result.result.success) {
        console.log('📊 个人中心获取云端统计数据成功:', result.result.data)
        this.setData({
          stats: result.result.data
        })
      } else {
        console.warn('📊 云端统计数据获取失败，使用本地数据')
        this.loadStatsFromLocal()
      }
    } catch (error) {
      console.error('❌ 个人中心加载统计数据失败:', error)
      // 降级到本地数据
      this.loadStatsFromLocal()
    }
  },

  // 从本地数据加载统计（降级方案）- 与用户订单页面统计逻辑保持一致
  loadStatsFromLocal() {
    console.log('📊 个人中心使用本地数据统计')

    const orders = wx.getStorageSync('orders') || []
    const projects = wx.getStorageSync('projects') || []

    // 统计订单数据 - 与用户订单页面统计逻辑保持一致
    const totalOrders = orders.length
    
    // 待处理 = 待接单（waiting_team标签页逻辑）
    const pendingOrders = orders.filter(order => 
      ['pending', 'waiting_team'].includes(order.status)
    ).length
    
    // 进行中 = 已接单 + 查勘中 + 设计中 + 已报价 + 施工中 + 验收中
    const activeOrders = orders.filter(order => 
      ['accepted', 'team_accepted', 'confirmed', 'surveying', 'designing', 'quoted', 'in_progress', 'testing'].includes(order.status)
    ).length
    
    // 已完成
    const completedOrders = orders.filter(order => 
      order.status === 'completed'
    ).length
    
    // 已取消
    const cancelledOrders = orders.filter(order => 
      order.status === 'cancelled'
    ).length
    
    const completionRate = totalOrders > 0 ? Math.round((completedOrders / totalOrders) * 100) : 0

    // 统计项目数据（备用）
    const totalProjects = projects.length
    const activeProjects = projects.filter(p => p.status === 'active' || p.status === 'planning').length
    const completedProjects = projects.filter(p => p.status === 'completed').length

    console.log('📊 个人中心本地统计结果:', {
      totalOrders,
      pendingOrders,
      activeOrders,
      completedOrders,
      cancelledOrders,
      completionRate
    })

    this.setData({
      stats: {
        totalOrders,
        pendingOrders,
        activeOrders,
        completedOrders,
        cancelledOrders,
        completionRate,
        // 项目统计（备用）
        totalProjects,
        activeProjects,
        completedProjects
      }
    })
  },

  // 刷新统计数据
  async refreshStats() {
    console.log('🔄 刷新个人中心统计数据')

    wx.showToast({
      title: '刷新中...',
      icon: 'loading',
      duration: 1000
    })

    await this.loadStats()

    wx.showToast({
      title: '数据已更新',
      icon: 'success',
      duration: 1500
    })
  },

  // 微信快捷登录
  async loginWithWechat() {
    console.log('🔐 用户点击微信快捷登录')

    // 记录登录尝试日志
    this.recordLoginLog('wechat_attempt', '用户点击微信快捷登录按钮')

    wx.showLoading({ title: '检查登录状态...' })

    try {
      // 先尝试获取云端用户信息
      const result = await wx.cloud.callFunction({
        name: 'userManager',
        data: {
          action: 'getUserInfo'
        }
      })

      if (result.result.success && result.result.userInfo) {
        const cloudUser = result.result.userInfo

        // 检查用户信息是否完整
        if (cloudUser.nickName && cloudUser.numericId) {
          // 用户已存在且信息完整，直接登录
          console.log('用户已存在且信息完整，直接登录')

          // 记录快捷登录成功日志
          this.recordLoginLog('wechat_quick_success', '用户快捷登录成功（已存在用户）')

          await this.handleLoginSuccess({
            isNewUser: false,
            userInfo: cloudUser
          })
          return
        } else {
          // 用户存在但信息不完整，需要完善信息
          console.log('用户存在但信息不完整，需要完善信息')

          // 清除本地不完整的登录状态
          wx.removeStorageSync('userInfo')
          wx.removeStorageSync('isLoggedIn')

          this.setData({
            isLoggedIn: false,
            userInfo: null
          })
        }
      }
    } catch (error) {
      console.log('云端用户信息检查失败，继续新用户注册流程:', error)

      // 清除可能存在的本地登录状态
      wx.removeStorageSync('userInfo')
      wx.removeStorageSync('isLoggedIn')

      this.setData({
        isLoggedIn: false,
        userInfo: null
      })
    }

    wx.hideLoading()

    // 新用户或信息不完整的用户，跳转到首次登录页面
    console.log('新用户或信息不完整，跳转到首次登录页面')

    // 记录首次登录日志
    this.recordLoginLog('first_login_redirect', '新用户或信息不完整跳转到首次登录页面')

    // 保存返回URL
    const returnUrl = this.data.returnUrl || '/pages/index/index'

    wx.navigateTo({
      url: `/pages/first-login/first-login?returnUrl=${encodeURIComponent(returnUrl)}`
    })
  },

  // 检测开发者环境
  checkDeveloperEnvironment() {
    try {
      const systemInfo = wx.getSystemInfoSync()
      console.log('🔍 系统信息检测:', systemInfo)
      
      // 检测是否在开发者工具中
      if (systemInfo.platform === 'devtools') {
        console.log('💻 检测到开发者工具环境')
        
        // 延迟显示提示，让用户先看到登录表单
        setTimeout(() => {
          if (this.data.showWechatForm) { // 确保表单仍然显示
            wx.showModal({
              title: '开发环境提示',
              content: '您正在使用微信开发者工具。\n\n头像选择功能在开发者工具中可能不稳定，建议在真机上测试完整功能。\n\n您可以暂时跳过头像设置，稍后在个人中心更新。',
              confirmText: '我知道了',
              showCancel: false
            })
          }
        }, 2000)
      }
    } catch (error) {
      console.log('🔍 环境检测失败:', error)
    }
  },

  // 选择头像（首次登录时使用）
  onChooseAvatarForLogin(e) {
    console.log('🎯 onChooseAvatarForLogin 函数被调用')
    console.log('📱 事件详情:', e.detail)
    console.log('📱 完整事件对象:', e)
    
    const { avatarUrl, errMsg } = e.detail || {}
    console.log('📸 提取的 avatarUrl:', avatarUrl)
    console.log('📸 错误信息:', errMsg)
    console.log('📸 avatarUrl 类型:', typeof avatarUrl)
    console.log('📸 avatarUrl 长度:', avatarUrl ? avatarUrl.length : 0)
    
    // 如果没有收到任何有效数据，可能是因为错误在更早的阶段发生
    if (!e.detail || (!avatarUrl && !errMsg)) {
      console.warn('⚠️ 未收到有效的头像数据，可能是开发者工具的已知问题')
      this.showDeveloperToolTip()
      return
    }
    
    // 检查是否有错误
    if (errMsg && errMsg.includes('fail')) {
      console.error('❌ 头像选择失败:', errMsg)
      this.handleAvatarChooseError(errMsg)
      return
    }
    
    if (avatarUrl && avatarUrl.trim()) {
      console.log('✅ avatarUrl 有效，开始更新数据')
      console.log('🔍 URL 格式检查:')
      console.log('  - 是否以 http 开头:', avatarUrl.startsWith('http'))
      console.log('  - 是否以 wxfile:// 开头:', avatarUrl.startsWith('wxfile://'))
      
      // 验证文件路径是否存在（仅在开发环境）
      if (avatarUrl.startsWith('wxfile://')) {
        console.log('🔍 检测到本地文件，验证文件是否存在...')
        this.validateAndUpdateAvatar(avatarUrl)
      } else {
        // 网络URL，直接更新
        this.updateTempAvatar(avatarUrl)
      }
    } else {
      console.error('❌ avatarUrl 无效或为空')
      wx.showToast({
        title: '未获取到头像',
        icon: 'none',
        duration: 2000
      })
    }
  },

  // 显示开发者工具提示
  showDeveloperToolTip() {
    wx.showModal({
      title: '开发者工具限制',
      content: '检测到您在使用微信开发者工具。由于开发者工具的限制，头像选择功能可能无法正常工作。\n\n建议：\n• 在真机上测试完整功能\n• 可以暂时跳过头像设置\n• 登录后在个人中心更新头像',
      confirmText: '我知道了',
      showCancel: false,
      success: (res) => {
        console.log('💡 用户已了解开发者工具的限制')
      }
    })
  },

  // 处理头像选择错误
  handleAvatarChooseError(errMsg) {
    if (errMsg.includes('ENOENT') || errMsg.includes('no such file')) {
      this.showDeveloperToolTip()
    } else if (errMsg.includes('cancel')) {
      console.log('👤 用户取消了头像选择')
      // 用户主动取消，不显示错误提示
    } else {
      wx.showToast({
        title: '头像选择失败',
        icon: 'none',
        duration: 2000
      })
    }
  },

  // 验证并更新头像
  validateAndUpdateAvatar(avatarUrl) {
    // 尝试获取文件信息来验证文件是否存在
    wx.getFileInfo({
      filePath: avatarUrl,
      success: (fileInfo) => {
        console.log('✅ 文件验证成功:', fileInfo)
        this.updateTempAvatar(avatarUrl)
      },
      fail: (error) => {
        console.error('❌ 文件验证失败:', error)
        this.showDeveloperToolTip()
      }
    })
  },

  // 更新临时头像的辅助函数
  updateTempAvatar(avatarUrl) {
    this.setData({
      tempAvatarUrl: avatarUrl,
      loginAvatarLoadError: false // 重置错误状态
    }, () => {
      console.log('✅ setData 完成，tempAvatarUrl 已更新:', this.data.tempAvatarUrl)
      console.log('🔍 当前页面数据状态:')
      console.log('  - showWechatForm:', this.data.showWechatForm)
      console.log('  - tempAvatarUrl:', this.data.tempAvatarUrl)
      console.log('  - userInfo.avatarUrl:', this.data.userInfo.avatarUrl)
      
      // 显示成功提示
      wx.showToast({
        title: '头像已选择',
        icon: 'success',
        duration: 1000
      })
    })
  },

  // 首次登录头像加载成功
  onLoginAvatarLoad(e) {
    console.log('🖼️ 首次登录头像加载成功:', e.detail)
    console.log('📸 当前显示的头像URL:', e.target.dataset.src || e.currentTarget.src)
  },

  // 首次登录头像加载失败
  onLoginAvatarError(e) {
    console.error('❌ 首次登录头像加载失败:', e.detail)
    console.error('📸 失败的头像URL:', e.target.dataset.src || e.currentTarget.src)
    console.error('📸 当前 tempAvatarUrl:', this.data.tempAvatarUrl)
    console.error('📸 当前 userInfo.avatarUrl:', this.data.userInfo.avatarUrl)
    
    // 设置错误标记，并清除无效的头像URL
    this.setData({
      loginAvatarLoadError: true,
      tempAvatarUrl: '' // 清除无效的URL，回退到默认头像
    }, () => {
      console.log('🔄 已清除无效头像URL，回退到默认头像')
    })
  },

  // 输入昵称
  onNicknameInput(e) {
    const { value } = e.detail
    this.setData({
      tempNickname: value
    })
  },

  // 取消微信登录
  cancelWechatLogin() {
    this.setData({
      showWechatForm: false,
      tempAvatarUrl: '',
      tempNickname: ''
    })
  },

  // 确认微信登录
  confirmWechatLogin() {
    const { tempAvatarUrl, tempNickname } = this.data

    if (!tempNickname.trim()) {
      wx.showToast({
        title: '请输入昵称',
        icon: 'none'
      })
      return
    }

    console.log('🔐 用户确认微信登录，昵称:', tempNickname.trim())

    // 记录确认登录日志
    this.recordLoginLog('wechat_confirm', `用户确认微信登录，昵称: ${tempNickname.trim()}`)

    wx.showLoading({ title: '正在登录...' })

    // 获取登录凭证
    wx.login({
      success: (loginRes) => {
        console.log('获取登录凭证成功:', loginRes.code)

        // 调用云函数进行登录
        this.callUserManagerFunction('login', {
          nickName: tempNickname.trim(),
          avatarUrl: tempAvatarUrl,
          code: loginRes.code
        })
      },
      fail: (loginErr) => {
        console.error('获取登录凭证失败:', loginErr)
        wx.hideLoading()
        wx.showToast({
          title: '登录失败，请重试',
          icon: 'none'
        })
      }
    })
  },

  // 调用用户管理云函数
  async callUserManagerFunction(action, userInfo = null) {
    try {
      console.log('调用用户管理云函数:', { action, userInfo })

      const result = await wx.cloud.callFunction({
        name: 'userManager',
        data: {
          action: action,
          userInfo: userInfo
        }
      })

      console.log('云函数调用结果:', result)

      if (result.result.success) {
        await this.handleLoginSuccess(result.result)
      } else {
        throw new Error(result.result.error || '登录失败')
      }
    } catch (error) {
      console.error('云函数调用失败:', error)
      wx.hideLoading()

      // 如果云函数不存在，降级到本地登录
      if (error.errCode === -501002 || error.message.includes('FunctionNotFound')) {
        console.log('云函数不存在，使用本地登录模式')
        wx.showToast({
          title: '使用本地登录模式',
          icon: 'none'
        })
        this.fallbackToLocalLogin()
      } else {
        wx.showToast({
          title: error.message || '登录失败，请重试',
          icon: 'none'
        })
      }
    }
  },

  // 处理登录成功
  async handleLoginSuccess(result) {
    const { isNewUser, userInfo } = result

    console.log('登录成功:', { isNewUser, userInfo })

    // 记录登录成功日志
    this.recordLoginLog('wechat_success', `微信登录成功 - ${isNewUser ? '新用户' : '老用户'}: ${userInfo.nickName}`)

    // 保存用户信息和登录状态
    wx.setStorageSync('userInfo', userInfo)
    wx.setStorageSync('isLoggedIn', true)

    this.setData({
      userInfo,
      isLoggedIn: true,
      avatarLoadError: false,
      showWechatForm: false,
      tempAvatarUrl: '',
      tempNickname: ''
    })

    wx.hideLoading()

    const welcomeMessage = isNewUser
      ? `欢迎加入，${userInfo.nickName}！`
      : `欢迎回来，${userInfo.nickName}！`

    wx.showToast({
      title: welcomeMessage,
      icon: 'success',
      duration: 2000
    })

    // 检查并处理临时头像文件
    if (userInfo.avatarUrl && this.isTempAvatarUrl(userInfo.avatarUrl)) {
      console.log('🔍 检测到临时头像文件，准备上传到云存储:', userInfo.avatarUrl)
      this.uploadTempAvatarToCloud(userInfo.avatarUrl)
    }

    // 重新加载统计数据
    this.loadStats()

    // 如果有返回URL，延迟跳转回原页面
    if (this.data.returnUrl) {
      console.log('登录成功，准备跳转回原页面:', this.data.returnUrl)
      setTimeout(() => {
        this.navigateToReturnUrl()
      }, 2500) // 等待toast显示完成后跳转
    }
  },

  // 降级到本地登录
  fallbackToLocalLogin() {
    const { tempAvatarUrl, tempNickname } = this.data

    setTimeout(() => {
      const userInfo = {
        nickName: tempNickname.trim(),
        avatarUrl: tempAvatarUrl,
        openid: 'local_' + Date.now(),
        loginTime: new Date().toISOString(),
        loginType: 'wechat',
        isLocal: true // 标记为本地登录
      }

      console.log('本地登录用户信息:', userInfo)

      // 保存用户信息和登录状态
      wx.setStorageSync('userInfo', userInfo)
      wx.setStorageSync('isLoggedIn', true)

      this.setData({
        userInfo,
        isLoggedIn: true,
        avatarLoadError: false,
        showWechatForm: false,
        tempAvatarUrl: '',
        tempNickname: ''
      })

      wx.hideLoading()
      wx.showToast({
        title: `欢迎，${userInfo.nickName}！`,
        icon: 'success',
        duration: 2000
      })

      // 检查并处理临时头像文件（本地登录模式）
      if (userInfo.avatarUrl && this.isTempAvatarUrl(userInfo.avatarUrl)) {
        console.log('🔍 本地登录检测到临时头像文件，准备上传到云存储:', userInfo.avatarUrl)
        this.uploadTempAvatarToCloud(userInfo.avatarUrl)
      }

      // 重新加载统计数据
      this.loadStats()

      // 如果有返回URL，延迟跳转回原页面
      if (this.data.returnUrl) {
        console.log('本地登录成功，准备跳转回原页面:', this.data.returnUrl)
        setTimeout(() => {
          this.navigateToReturnUrl()
        }, 2500) // 等待toast显示完成后跳转
      }
    }, 500)
  },

  // 跳转到返回URL的方法
  navigateToReturnUrl() {
    const returnUrl = this.data.returnUrl
    if (!returnUrl) {
      console.log('没有返回URL，跳转取消')
      return
    }

    console.log('开始跳转到:', returnUrl)

    // 清除返回URL，避免重复跳转
    this.setData({ returnUrl: '' })

    // 尝试多种跳转方式
    wx.navigateTo({
      url: returnUrl,
      success: () => {
        console.log('✅ navigateTo 跳转成功')
      },
      fail: (error) => {
        console.log('❌ navigateTo 失败，尝试 redirectTo:', error)
        wx.redirectTo({
          url: returnUrl,
          success: () => {
            console.log('✅ redirectTo 跳转成功')
          },
          fail: (error2) => {
            console.log('❌ redirectTo 失败，尝试 reLaunch:', error2)
            wx.reLaunch({
              url: returnUrl,
              success: () => {
                console.log('✅ reLaunch 跳转成功')
              },
              fail: (error3) => {
                console.error('❌ 所有跳转方式都失败:', error3)
                wx.showToast({
                  title: '页面跳转失败',
                  icon: 'none'
                })
              }
            })
          }
        })
      }
    })
  },

  // 检查云端用户信息
  async checkCloudUserInfo() {
    const isLoggedIn = wx.getStorageSync('isLoggedIn')

    if (!isLoggedIn) {
      console.log('用户未登录，跳过云端信息检查')
      return
    }

    try {
      console.log('检查云端用户信息...')

      const result = await wx.cloud.callFunction({
        name: 'userManager',
        data: {
          action: 'getUserInfo'
        }
      })

      console.log('云端用户信息查询结果:', result)

      if (result.result.success) {
        const cloudUserInfo = result.result.userInfo
        const localUserInfo = wx.getStorageSync('userInfo') || {}

        // 如果云端有更新的信息，则更新本地
        if (this.shouldUpdateLocalInfo(localUserInfo, cloudUserInfo)) {
          console.log('更新本地用户信息')

          const updatedUserInfo = {
            ...localUserInfo,
            ...cloudUserInfo,
            loginType: 'wechat'
          }

          wx.setStorageSync('userInfo', updatedUserInfo)

          this.setData({
            userInfo: updatedUserInfo,
            avatarLoadError: false
          })

          wx.showToast({
            title: '已同步最新信息',
            icon: 'success',
            duration: 1500
          })
        }
      }
    } catch (error) {
      console.log('云端用户信息检查失败:', error)
      // 静默失败，不影响用户体验
    }
  },

  // 判断是否需要更新本地信息
  shouldUpdateLocalInfo(localInfo, cloudInfo) {
    if (!cloudInfo) return false

    // 检查关键信息是否有差异
    const keyFields = ['nickName', 'avatarUrl', 'lastLoginTime']

    for (const field of keyFields) {
      if (cloudInfo[field] && cloudInfo[field] !== localInfo[field]) {
        return true
      }
    }

    return false
  },

  // 初始化数据库（开发测试用）
  async initDatabase() {
    wx.showLoading({ title: '初始化数据库...' })

    try {
      const result = await wx.cloud.callFunction({
        name: 'initDatabase',
        data: {}
      })

      wx.hideLoading()

      if (result.result.success) {
        wx.showToast({
          title: '数据库初始化成功',
          icon: 'success'
        })
      } else {
        wx.showToast({
          title: result.result.error || '初始化失败',
          icon: 'none'
        })
      }
    } catch (error) {
      wx.hideLoading()
      console.error('数据库初始化失败:', error)
      wx.showToast({
        title: '初始化失败',
        icon: 'none'
      })
    }
  },

  // 头像点击事件
  onAvatarTap() {
    if (!this.data.tapCount) {
      this.setData({ tapCount: 0 })
    }
    
    this.setData({ 
      tapCount: this.data.tapCount + 1 
    })
    
    // 静默计数，不输出日志
    
    // 连续点击5次触发开发者菜单（隐藏功能）
    if (this.data.tapCount >= 5) {
      this.setData({ tapCount: 0 })
      // 直接触发，不显示明显提示
      this.showDeveloperMenu()
      return
    }
    
    // 单次点击显示头像选择菜单
    if (this.data.tapCount === 1) {
      setTimeout(() => {
        if (this.data.tapCount === 1) {
          // 只有单次点击时才显示头像选择
          this.showAvatarOptions()
        }
      }, 300)
    }
    
    // 2秒后重置计数
    setTimeout(() => {
      this.setData({ tapCount: 0 })
    }, 2000)
  },

  // 显示头像选择选项
  showAvatarOptions() {
    console.log('👤 显示头像选择菜单')

    wx.showActionSheet({
      itemList: ['用微信头像', '从相册选择', '拍照'],
      success: (res) => {
        switch (res.tapIndex) {
          case 0:
            this.useWechatAvatar()
            break
          case 1:
            this.chooseFromAlbum()
            break
          case 2:
            this.takePhoto()
            break
        }
      }
    })
  },



  // 使用微信头像
  async useWechatAvatar() {
    console.log('📱 用户选择使用微信头像')

    wx.showModal({
      title: '获取微信头像',
      content: '将使用微信官方的头像昵称填写组件来获取您的微信头像。\n\n点击确定后，您可以选择分享微信头像给小程序使用。',
      confirmText: '获取',
      cancelText: '取消',
      success: (res) => {
        if (res.confirm) {
          this.showWechatAvatarPicker()
        }
      }
    })
  },

  // 显示微信头像选择器
  showWechatAvatarPicker() {
    console.log('📱 显示微信头像选择器')
    
    // 设置显示头像选择器的状态
    this.setData({
      showWechatAvatarPicker: true
    })
  },

  // 微信头像选择器选择事件
  onWechatAvatarChoose(e) {
    console.log('📱 微信头像选择器选择:', e.detail)
    
    const { avatarUrl } = e.detail
    if (avatarUrl) {
      console.log('✅ 获取到微信头像:', avatarUrl)
      
      // 隐藏选择器
      this.setData({
        showWechatAvatarPicker: false
      })
      
      // 确认使用微信头像
      wx.showModal({
        title: '确认使用微信头像',
        content: '获取到您的微信头像，确定要设置为小程序头像吗？',
        confirmText: '确定使用',
        cancelText: '重新选择',
        success: (modalRes) => {
          if (modalRes.confirm) {
            // 处理微信头像
            this.processWechatAvatar(avatarUrl)
          } else {
            // 重新显示选择器
            this.setData({
              showWechatAvatarPicker: true
            })
          }
        }
      })
    } else {
      console.error('❌ 微信头像选择器返回的avatarUrl为空')
      wx.showToast({
        title: '获取头像失败',
        icon: 'none'
      })
    }
  },

  // 微信头像选择器关闭事件
  onWechatAvatarPickerClose() {
    console.log('📱 微信头像选择器关闭')
    this.setData({
      showWechatAvatarPicker: false
    })
  },

  // 处理微信头像
  async processWechatAvatar(avatarUrl) {
    console.log('📥 处理微信头像:', avatarUrl)

    wx.showLoading({
      title: '处理头像中...',
      mask: true
    })

    try {
      // 检查头像URL类型
      if (avatarUrl.startsWith('wxfile://')) {
        // 本地临时文件，直接上传
        console.log('📁 检测到本地临时文件，直接上传')
        await this.uploadAndSaveAvatar(avatarUrl, 'wechat_avatar')
      } else if (avatarUrl.startsWith('http')) {
        // 网络文件，先下载再上传
        console.log('🌐 检测到网络文件，先下载再上传')
        await this.downloadAndUploadWechatAvatar(avatarUrl)
      } else {
        throw new Error('不支持的头像文件格式')
      }

      wx.hideLoading()
      
      wx.showToast({
        title: '微信头像设置成功',
        icon: 'success'
      })

    } catch (error) {
      wx.hideLoading()
      console.error('❌ 处理微信头像失败:', error)

      wx.showModal({
        title: '设置头像失败',
        content: `错误信息：${error.message}\n\n建议使用"从相册选择"功能`,
        confirmText: '选择',
        cancelText: '知道了',
        success: (res) => {
          if (res.confirm) {
            this.chooseFromAlbum()
          }
        }
      })
    }
  },

  // 下载并上传微信头像
  async downloadAndUploadWechatAvatar(avatarUrl) {
    console.log('📥 下载微信头像:', avatarUrl)

    wx.showLoading({
      title: '处理头像中...',
      mask: true
    })

    try {
      // 下载微信头像到本地
      const downloadResult = await new Promise((resolve, reject) => {
        wx.downloadFile({
          url: avatarUrl,
          success: (result) => {
            if (result.statusCode === 200) {
              resolve(result)
            } else {
              reject(new Error(`下载失败，状态码: ${result.statusCode}`))
            }
          },
          fail: reject
        })
      })

      console.log('📥 微信头像下载成功:', downloadResult.tempFilePath)

      if (downloadResult.tempFilePath) {
        wx.hideLoading()
        // 使用下载的本地文件路径上传
        this.uploadAndSaveAvatar(downloadResult.tempFilePath, 'wechat')
      } else {
        throw new Error('下载的头像文件路径为空')
      }

    } catch (error) {
      wx.hideLoading()
      console.error('📥 下载微信头像失败:', error)

      wx.showModal({
        title: '处理头像失败',
        content: `错误信息：${error.message || error.errMsg}\n\n建议使用"从相册选择"功能`,
        confirmText: '选择',
        cancelText: '知道了',
        success: (res) => {
          if (res.confirm) {
            this.chooseFromAlbum()
          }
        }
      })
    }
  },

  // 显示头像选择弹窗
  async showAvatarSelectionModal() {
    // 如果没有微信头像信息，先尝试获取
    if (!this.data.wechatAvatarUrl) {
      try {
        await this.loadWechatUserInfo()
      } catch (error) {
        console.log('💡 无法获取微信头像信息，将在选择器中提供获取选项')
      }
    }

    // 显示自定义头像选择器
    this.setData({
      showAvatarSelector: true
    })
  },

  // 头像选择器选择事件
  onAvatarSelect(e) {
    const { type, avatarUrl } = e.detail
    console.log('🎯 头像选择器选择:', type, avatarUrl)

    switch (type) {
      case 'wechat':
        // 使用微信头像
        this.useWechatAvatar()
        break
      case 'getWechat':
        // 获取微信头像
        this.getWechatAvatarAndUse()
        break
      case 'album':
        // 从相册选择
        this.chooseFromAlbum()
        break
      case 'camera':
        // 拍照
        this.takePhoto()
        break
    }
  },

  // 头像选择器关闭事件
  onAvatarSelectorClose() {
    this.setData({
      showAvatarSelector: false
    })
  },

  // 显示微信头像选择弹窗
  showWechatAvatarModal() {
    const wechatNickname = this.data.wechatNickname || '微信用户'

    wx.showModal({
      title: '选择头像',
      content: `🖼️ 使用微信头像\n👤 ${wechatNickname}\n\n或选择其他方式：`,
      confirmText: '使用',
      cancelText: '其他方式',
      success: (res) => {
        if (res.confirm) {
          // 使用微信头像
          this.useWechatAvatar()
        } else {
          // 显示其他选择方式
          wx.showActionSheet({
            itemList: ['从相册选择', '拍照'],
            success: (actionRes) => {
              switch (actionRes.tapIndex) {
                case 0:
                  this.chooseFromAlbum()
                  break
                case 1:
                  this.takePhoto()
                  break
              }
            }
          })
        }
      }
    })
  },

  // 获取并使用微信头像
  async getWechatAvatarAndUse() {
    console.log('📱 获取并使用微信头像')

    try {
      wx.showLoading({
        title: '获取微信头像...',
        mask: true
      })

      // 请求获取微信用户信息
      const userInfo = await this.requestWechatUserInfo()
      wx.hideLoading()

      // 确认使用微信头像
      wx.showModal({
        title: '确认使用微信头像',
        content: `获取到您的微信头像\n昵称：${userInfo.nickName}\n\n确定要设置为头像吗？`,
        confirmText: '确定使用',
        cancelText: '取消',
        success: (res) => {
          if (res.confirm) {
            this.useWechatAvatar()
          }
        }
      })

    } catch (error) {
      wx.hideLoading()
      console.error('❌ 获取微信头像失败:', error)

      wx.showModal({
        title: '获取失败',
        content: '无法获取微信头像，可能是用户拒绝授权。\n\n请选择其他方式上传头像。',
        showCancel: false,
        confirmText: '知道了'
      })
    }
  },

  // 使用微信头像
  async useWechatAvatar() {
    console.log('📱 用户选择使用微信头像')
    
    // 直接显示微信头像选择器，让用户选择头像
    this.showWechatAvatarPicker()
  },



  // 获取微信用户信息
  async loadWechatUserInfo() {
    console.log('📱 获取微信用户信息')

    try {
      // 尝试使用新的API获取用户信息
      if (wx.canIUse('getUserProfile')) {
        // 静默获取，不弹出授权框
        const userInfo = wx.getStorageSync('wechatUserInfo')
        if (userInfo && userInfo.avatarUrl) {
          console.log('📱 从缓存获取微信用户信息:', userInfo)
          this.setData({
            wechatAvatarUrl: userInfo.avatarUrl,
            wechatNickname: userInfo.nickName || '微信用户'
          })
          return
        }
      }

      // 尝试从当前用户信息中获取
      const currentUserInfo = this.data.userInfo
      if (currentUserInfo && currentUserInfo.avatarUrl && currentUserInfo.avatarUrl.includes('wx.qlogo.cn')) {
        console.log('📱 从当前用户信息获取微信头像')
        this.setData({
          wechatAvatarUrl: currentUserInfo.avatarUrl,
          wechatNickname: currentUserInfo.nickName || '微信用户'
        })
        return
      }

      console.log('💡 未找到缓存的微信用户信息，需要用户授权获取')

    } catch (error) {
      console.error('❌ 获取微信用户信息失败:', error)
    }
  },

  // 请求获取微信用户信息（已废弃）
  async requestWechatUserInfo() {
    console.log('📱 请求获取微信用户信息（API已废弃）')

    // 直接返回错误，提示用户使用新的方式
    return Promise.reject(new Error('getUserProfile API已废弃，请使用头像昵称填写组件'))
  },

  // 检查头像设置
  checkAvatarSetup() {
    const userInfo = this.data.userInfo

    // 检查是否是首次登录或没有设置头像
    if (userInfo && userInfo.isLoggedIn) {
      const hasAvatar = userInfo.avatarUrl &&
                       userInfo.avatarUrl !== '' &&
                       !userInfo.avatarUrl.includes('default') &&
                       !this.data.avatarLoadError

      if (!hasAvatar) {
        console.log('👤 检测到用户没有设置头像，显示设置提示')

        // 延迟显示，避免与其他弹窗冲突
        setTimeout(() => {
          wx.showModal({
            title: '🖼️ 设置头像',
            content: '您还没有设置个人头像，是否现在设置？\n\n可以使用微信头像、从相册选择或拍照',
            confirmText: '设置头像',
            cancelText: '稍后再说',
            success: (res) => {
              if (res.confirm) {
                this.onAvatarTap()
              }
            }
          })
        }, 2000)
      }
    }
  },

  // 选择微信头像
  async chooseWechatAvatar() {
    console.log('📱 选择微信头像')

    // 先检查用户信息和云开发状态
    this.debugUserAndCloudStatus()

    try {
      // 如果还没有微信头像信息，先获取
      if (!this.data.wechatAvatarUrl) {
        wx.showLoading({
          title: '获取微信信息...',
          mask: true
        })

        await this.requestWechatUserInfo()
        wx.hideLoading()
      }

      // 显示微信头像选择弹窗
      this.showWechatAvatarModal()

    } catch (error) {
      wx.hideLoading()
      console.error('❌ 获取微信用户信息失败:', error)

      // 如果获取失败，提供其他选择方式
      wx.showModal({
        title: '获取微信信息失败',
        content: '无法获取微信头像信息，请选择其他方式：\n\n✅ 头像按钮：微信官方推荐方式\n✅ 相册选择：从手机相册选择',
        confirmText: '启用',
        cancelText: '从相册选择',
        success: (res) => {
          if (res.confirm) {
            // 头像按钮已默认启用，直接提示用户
            wx.showToast({
              title: '请直接点击头像选择',
              icon: 'none',
              duration: 2000
            })
          } else {
            this.chooseFromAlbum()
          }
        }
      })
    }
  },



  // 使用头像按钮组件选择头像（已登录用户使用）
  onChooseAvatar(e) {
    console.log('📱 通过头像按钮选择头像:', e.detail)

    const { avatarUrl } = e.detail
    if (avatarUrl) {
      console.log('✅ 获取到头像URL:', avatarUrl)
      console.log('🔍 头像URL类型:', typeof avatarUrl)
      console.log('🔍 头像URL长度:', avatarUrl.length)

      // 检查是否是有效的URL
      if (avatarUrl.startsWith('http') || avatarUrl.startsWith('wxfile://')) {
        // 显示确认提示
        wx.showModal({
          title: '确认使用此头像',
          content: '您选择了新的头像，确定要更新吗？',
          confirmText: '确定更新',
          cancelText: '重新选择',
          success: (res) => {
            if (res.confirm) {
              // 根据URL类型选择处理方式
              if (avatarUrl.startsWith('wxfile://')) {
                // 本地文件，直接上传
                console.log('📁 检测到本地文件，直接上传')
                this.uploadAndSaveAvatar(avatarUrl, 'wechat_button')
              } else {
                // 网络文件，先下载再上传
                console.log('🌐 检测到网络文件，先下载再上传')
                this.downloadAndUploadWechatAvatar(avatarUrl)
              }
            }
          }
        })
      } else {
        console.error('❌ 无效的头像URL格式:', avatarUrl)
        wx.showToast({
          title: '头像格式不支持',
          icon: 'none'
        })
      }
    } else {
      console.error('❌ 头像按钮返回的avatarUrl为空')
      wx.showToast({
        title: '获取头像失败',
        icon: 'none'
      })
    }
  },

  // 检查微信版本和API支持
  checkWechatVersion() {
    try {
      const systemInfo = wx.getSystemInfoSync()
      console.log('📱 系统信息:', systemInfo)

      // 检查是否支持新的头像选择API
      if (wx.canIUse('button.open-type.chooseAvatar')) {
        console.log('✅ 支持新版头像选择API')

        // 如果用户还没有头像，建议使用新版API
        const userInfo = this.data.userInfo || {}
        if (!userInfo.avatarUrl || this.data.avatarLoadError) {
          // 可以在这里提示用户使用新版头像选择
          console.log('💡 建议用户使用新版头像选择功能')
        }
      } else {
        console.log('⚠️ 不支持新版头像选择API，使用传统方式')
        wx.showToast({
          title: '请更新微信版本',
          icon: 'none'
        })
      }
    } catch (error) {
      console.error('❌ 检查微信版本失败:', error)
    }
  },

  // 调试用户信息和云开发状态
  debugUserAndCloudStatus() {
    console.log('🔍 调试信息:')
    console.log('- 用户信息:', this.data.userInfo)
    console.log('- 登录状态:', this.data.isLoggedIn)

    // 获取云开发环境信息
    const app = getApp()
    const envId = 'cloud1-8gge1454b08b1f51' // 直接使用配置的环境ID
    console.log('- 云开发环境就绪:', app.globalData.cloudEnvReady)
    console.log('- 配置的环境ID:', envId)
    console.log('- wx.cloud.env:', wx.cloud.env || '未设置')

    // 检查云开发初始化状态
    if (!app.globalData.cloudEnvReady) {
      console.error('❌ 云开发环境未就绪')
      wx.showModal({
        title: '云开发环境错误',
        content: '云开发环境未正确初始化，请检查配置',
        showCancel: false
      })
      return
    }

    // 测试云函数连接
    wx.cloud.callFunction({
      name: 'userManager',
      data: {
        action: 'debugUserInfo'
      },
      success: (result) => {
        console.log('🔍 云函数测试成功:', result)
      },
      fail: (error) => {
        console.error('🔍 云函数测试失败:', error)
        wx.showModal({
          title: '云函数测试失败',
          content: `错误信息：${error.errMsg || error.message}`,
          showCancel: false
        })
      }
    })
  },

  // 下载并上传微信头像
  async downloadAndUploadWechatAvatar(avatarUrl) {
    console.log('📥 下载微信头像:', avatarUrl)

    // 检查URL是否有效
    if (!avatarUrl || typeof avatarUrl !== 'string') {
      console.error('❌ 头像URL无效:', avatarUrl)
      wx.showToast({
        title: '头像URL无效',
        icon: 'none'
      })
      return
    }

    wx.showLoading({
      title: '获取头像中...',
      mask: true
    })

    try {
      console.log('📥 开始下载头像文件')

      // 下载微信头像到本地
      const downloadResult = await new Promise((resolve, reject) => {
        wx.downloadFile({
          url: avatarUrl,
          success: (result) => {
            console.log('📥 下载结果:', result)
            if (result.statusCode === 200) {
              resolve(result)
            } else {
              reject(new Error(`下载失败，状态码: ${result.statusCode}`))
            }
          },
          fail: (error) => {
            console.error('📥 下载失败:', error)
            reject(error)
          }
        })
      })

      console.log('📥 微信头像下载成功:', downloadResult)

      if (downloadResult.tempFilePath) {
        wx.hideLoading()
        console.log('✅ 获得临时文件路径:', downloadResult.tempFilePath)
        // 使用下载的本地文件路径上传
        this.uploadAndSaveAvatar(downloadResult.tempFilePath, 'wechat')
      } else {
        throw new Error('下载的头像文件路径为空')
      }

    } catch (error) {
      wx.hideLoading()
      console.error('📥 下载微信头像失败:', error)

      let errorMessage = '获取头像失败'
      if (error.errMsg) {
        errorMessage = error.errMsg
      } else if (error.message) {
        errorMessage = error.message
      }

      wx.showModal({
        title: '下载头像失败',
        content: `错误信息：${errorMessage}\n\n建议使用"从相册选择"功能`,
        confirmText: '选择',
        cancelText: '知道了',
        success: (res) => {
          if (res.confirm) {
            this.chooseFromAlbum()
          }
        }
      })
    }
  },

  // 从相册选择头像
  chooseFromAlbum() {
    console.log('📷 从相册选择头像')

    wx.chooseMedia({
      count: 1,
      mediaType: ['image'],
      sourceType: ['album'],
      maxDuration: 30,
      camera: 'back',
      success: (res) => {
        console.log('选择图片成功:', res)

        if (res.tempFiles && res.tempFiles.length > 0) {
          const tempFilePath = res.tempFiles[0].tempFilePath
          this.uploadAndSaveAvatar(tempFilePath, 'album')
        }
      },
      fail: (error) => {
        console.error('选择图片失败:', error)
        wx.showToast({
          title: '选择图片失败',
          icon: 'none'
        })
      }
    })
  },

  // 拍照选择头像
  takePhoto() {
    console.log('📸 拍照选择头像')

    wx.chooseMedia({
      count: 1,
      mediaType: ['image'],
      sourceType: ['camera'],
      maxDuration: 30,
      camera: 'front', // 前置摄像头更适合自拍
      success: (res) => {
        console.log('拍照成功:', res)

        if (res.tempFiles && res.tempFiles.length > 0) {
          const tempFilePath = res.tempFiles[0].tempFilePath
          this.uploadAndSaveAvatar(tempFilePath, 'camera')
        }
      },
      fail: (error) => {
        console.error('拍照失败:', error)
        wx.showToast({
          title: '拍照失败',
          icon: 'none'
        })
      }
    })
  },

  // 上传并保存头像
  async uploadAndSaveAvatar(filePath, source) {
    console.log('🔄 开始上传头像:', filePath, '来源:', source)

    // 详细记录当前用户状态
    const userInfo = this.data.userInfo || {}
    console.log('👤 当前用户状态:', {
      hasUserInfo: !!userInfo,
      hasOpenid: !!userInfo.openid,
      hasUserId: !!userInfo.userId,
      isLoggedIn: userInfo.isLoggedIn,
      openid: userInfo.openid ? userInfo.openid.substring(0, 10) + '...' : 'null',
      userId: userInfo.userId || 'null'
    })

    // 检查云开发环境
    if (!this.checkCloudEnvironment()) {
      wx.showToast({
        title: '云开发环境未就绪',
        icon: 'none'
      })
      return
    }

    wx.showLoading({
      title: '上传头像中...',
      mask: true
    })

    try {
      // 1. 上传到云存储
      const uploadResult = await this.uploadAvatarToCloud(filePath)
      console.log('☁️ 头像上传到云存储成功:', uploadResult)

      // 2. 保存到数据库
      const saveResult = await this.saveAvatarToDatabase(uploadResult.fileID, source)
      console.log('💾 头像保存到数据库成功:', saveResult)

      // 3. 更新本地数据
      const updatedUserInfo = {
        ...this.data.userInfo,
        avatarUrl: uploadResult.fileID
      }
      
      this.setData({
        userInfo: updatedUserInfo,
        avatarLoadError: false,
        // 如果首次登录对话框正在显示，也更新临时头像
        tempAvatarUrl: this.data.showWechatForm ? uploadResult.fileID : this.data.tempAvatarUrl
      })

      // 同步更新本地存储
      wx.setStorageSync('userInfo', updatedUserInfo)

      wx.hideLoading()
      wx.showToast({
        title: '头像更新成功',
        icon: 'success'
      })

    } catch (error) {
      wx.hideLoading()
      console.error('❌ 头像上传失败:', error)

      // 显示具体的错误信息
      let errorMessage = '头像更新失败'
      if (error.message) {
        errorMessage = error.message
      } else if (error.errMsg) {
        errorMessage = error.errMsg
      }

      // 分类处理不同类型的错误
      console.error('❌ 头像更新错误详情:', errorMessage)
      
      if (errorMessage.includes('用户不存在') || errorMessage.includes('首次登录数据未同步完成')) {
        // 理论上不应该再出现这个错误，因为我们已经预先处理了用户存在性
        console.error('⚠️ 意外的用户不存在错误，这不应该发生')
        
        wx.showModal({
          title: '数据异常',
          content: '遇到了意外的数据问题，建议重新登录后再试。',
          confirmText: '重新登录',
          cancelText: '取消',
          success: (res) => {
            if (res.confirm) {
              this.forceRelogin()
            }
          }
        })
      } else if (errorMessage.includes('用户身份信息缺失')) {
        // 身份信息缺失问题
        wx.showModal({
          title: '登录状态异常',
          content: '登录状态可能已过期，请重新登录。',
          confirmText: '重新登录',
          cancelText: '取消',
          success: (res) => {
            if (res.confirm) {
              this.forceRelogin()
            }
          }
        })
      } else if (errorMessage.includes('网络') || errorMessage.includes('连接') || errorMessage.includes('超时')) {
        // 网络相关错误
        wx.showModal({
          title: '网络错误',
          content: '网络连接异常，请检查网络后重试。',
          confirmText: '重试',
          cancelText: '取消',
          success: (res) => {
            if (res.confirm) {
              // 用户选择重试，可以重新调用上传函数
              wx.showToast({
                title: '请重新选择头像',
                icon: 'none'
              })
            }
          }
        })
      } else {
        // 其他未知错误 - 添加详细的调试信息
        console.error('❌ 详细错误信息:', {
          errorMessage: errorMessage,
          originalError: error,
          userInfo: this.data.userInfo,
          timestamp: new Date().toISOString()
        })
        
        wx.showModal({
          title: '头像更新失败',
          content: `操作失败，请重试。\n\n错误信息：${errorMessage}`,
          confirmText: '重试',
          cancelText: '查看详情',
          success: (res) => {
            if (res.confirm) {
              wx.showToast({
                title: '请重新选择头像',
                icon: 'none'
              })
            } else {
              // 显示详细的错误信息用于调试
              wx.showModal({
                title: '错误详情',
                content: `错误信息：${errorMessage}\n\n如果问题持续存在，请联系技术支持。`,
                showCancel: false,
                confirmText: '确定'
              })
            }
          }
        })
      }
    }
  },

  // 上传头像到云存储
  async uploadAvatarToCloud(filePath) {
    console.log('☁️ 开始上传头像到云存储:', filePath)

    // 检查文件路径
    if (!filePath) {
      throw new Error('文件路径不能为空')
    }

    // 获取用户ID，如果没有则使用openid或随机ID
    const userInfo = this.data.userInfo || {}
    const userId = userInfo.userId || userInfo.openid || `user_${Date.now()}`

    const timestamp = Date.now()
    const random = Math.random().toString(36).substr(2, 9)
    const fileName = `avatars/${userId}_${timestamp}_${random}.jpg`

    console.log('☁️ 上传文件名:', fileName)

    return new Promise((resolve, reject) => {
      console.log('☁️ 开始调用 wx.cloud.uploadFile')
      console.log('- cloudPath:', fileName)
      console.log('- filePath:', filePath)

      wx.cloud.uploadFile({
        cloudPath: fileName,
        filePath: filePath,
        success: (result) => {
          console.log('☁️ 文件上传成功:', result)
          if (result.fileID) {
            console.log('✅ 获得 fileID:', result.fileID)
            resolve(result)
          } else {
            console.error('❌ 上传成功但未返回fileID')
            reject(new Error('上传成功但未返回fileID'))
          }
        },
        fail: (error) => {
          console.error('☁️ 文件上传失败:', error)
          console.error('- 错误码:', error.errCode)
          console.error('- 错误信息:', error.errMsg)
          reject(error)
        }
      })
    })
  },

  // 检查用户是否存在
  async checkUserExists() {
    console.log('🔍 检查用户是否存在...')
    
    try {
      const result = await new Promise((resolve, reject) => {
        wx.cloud.callFunction({
          name: 'userManager',
          data: {
            action: 'getUserInfo'
            // 不需要传递openid，云函数会自动从wxContext获取
          },
          success: (res) => {
            console.log('🔍 检查用户存在结果:', res)
            resolve(res.result)
          },
          fail: (error) => {
            console.error('🔍 检查用户存在失败:', error)
            reject(error)
          }
        })
      })
      
      return {
        exists: result.success,
        userInfo: result.userInfo || null,
        error: result.error || null
      }
    } catch (error) {
      console.error('🔍 检查用户存在异常:', error)
      return {
        exists: false,
        userInfo: null,
        error: error.message || '检查失败'
      }
    }
  },

  // 创建用户记录
  async createUserRecord() {
    console.log('👤 创建用户记录...')
    
    try {
      const result = await new Promise((resolve, reject) => {
        wx.cloud.callFunction({
          name: 'userManager',
          data: {
            action: 'login',
            userInfo: {
              nickName: '微信用户',
              avatarUrl: '',
              gender: 0
            }
          },
          success: (res) => {
            console.log('👤 创建用户记录结果:', res)
            resolve(res.result)
          },
          fail: (error) => {
            console.error('👤 创建用户记录失败:', error)
            reject(error)
          }
        })
      })
      
      if (result.success) {
        // 更新本地用户信息
        this.setData({
          userInfo: {
            ...this.data.userInfo,
            ...result.userInfo
          }
        })
        
        return {
          success: true,
          userInfo: result.userInfo
        }
      } else {
        return {
          success: false,
          error: result.error || '创建用户失败'
        }
      }
    } catch (error) {
      console.error('👤 创建用户记录异常:', error)
      return {
        success: false,
        error: error.message || '创建用户异常'
      }
    }
  },

  // 保存头像信息到数据库（智能处理用户存在性）
  async saveAvatarToDatabase(fileID, source) {
    console.log('💾 开始保存头像信息到数据库:', { fileID, source })

    if (!fileID) {
      throw new Error('文件ID不能为空')
    }

    // 第一步：检查用户是否存在
    const userCheckResult = await this.checkUserExists()
    console.log('💾 用户存在检查结果:', userCheckResult)

    if (!userCheckResult.exists) {
      console.log('💾 用户不存在，尝试创建用户记录...')
      
      // 用户不存在的情况：先创建用户记录
      const createResult = await this.createUserRecord()
      
      if (!createResult.success) {
        throw new Error(`创建用户失败: ${createResult.error}`)
      }
      
      console.log('💾 用户创建成功，继续保存头像...')
    } else {
      console.log('💾 用户已存在，直接保存头像...')
    }

    // 第二步：保存头像信息
    return new Promise((resolve, reject) => {
      // 获取最新的用户信息
      const currentUserInfo = this.data.userInfo || {}
      const finalUserId = currentUserInfo.userId
      const finalOpenid = currentUserInfo.openid
      
      console.log('💾 最终使用的用户信息:', { 
        finalUserId, 
        finalOpenid: finalOpenid ? finalOpenid.substring(0, 10) + '...' : 'null' 
      })
      
      wx.cloud.callFunction({
        name: 'userManager',
        data: {
          action: 'updateAvatar',
          userId: finalUserId,
          avatarUrl: fileID,
          avatarSource: source,
          updateTime: new Date()
        },
        success: (result) => {
          console.log('💾 头像信息保存成功:', result)

          // 检查云函数返回结果
          if (result.result && result.result.success) {
            resolve(result)
          } else {
            const errorMsg = result.result ? result.result.error : '云函数返回异常'
            console.error('💾 云函数执行失败:', errorMsg)
            reject(new Error(errorMsg))
          }
        },
        fail: (error) => {
          console.error('💾 头像信息保存失败:', error)
          reject(error)
        }
      })
    })
  },

  // 初始化施工队伍数据
  initConstructionTeams() {
    console.log('🏗️ 开始初始化施工队伍数据')

    wx.showModal({
      title: '初始化施工队伍数据',
      content: '这将清空现有的施工队伍数据并重新初始化，确定要继续吗？',
      confirmText: '确定',
      cancelText: '取消',
      success: (res) => {
        if (res.confirm) {
          console.log('✅ 用户确认初始化，开始执行')
          this.executeInitConstructionTeams()
        } else {
          console.log('❌ 用户取消初始化')
        }
      },
      fail: (error) => {
        console.error('❌ 显示确认弹窗失败:', error)
      }
    })
  },

  // 执行施工队伍数据初始化
  async executeInitConstructionTeams() {
    console.log('🚀 开始执行施工队伍数据初始化')

    wx.showLoading({
      title: '正在初始化...',
      mask: true
    })

    try {
      console.log('📞 调用云函数 initConstructionTeams')

      const result = await wx.cloud.callFunction({
        name: 'initConstructionTeams',
        data: { debug: false }
      })

      wx.hideLoading()
      console.log('📊 云函数返回结果:', result)

      if (result.result && result.result.success) {
        console.log('✅ 施工队伍数据初始化成功:', result.result)
        wx.showModal({
          title: '初始化成功',
          content: `施工队伍数据初始化完成！\n\n共初始化 ${result.result.data?.totalCount || 0} 条数据`,
          showCancel: false,
          confirmText: '确定'
        })
      } else {
        const errorMsg = result.result ? result.result.error : '云函数返回异常'
        console.error('❌ 云函数执行失败:', errorMsg)
        wx.showModal({
          title: '初始化失败',
          content: `云函数执行失败：${errorMsg}`,
          showCancel: false,
          confirmText: '确定'
        })
      }

    } catch (error) {
      wx.hideLoading()
      console.error('❌ 调用云函数失败:', error)

      let errorMsg = '未知错误'
      if (error.errMsg && error.errMsg.includes('FunctionName parameter could not be found')) {
        errorMsg = '云函数 initConstructionTeams 未找到，请确认是否已正确部署'
      } else if (error.errMsg) {
        errorMsg = error.errMsg
      } else if (error.message) {
        errorMsg = error.message
      }

      wx.showModal({
        title: '调用失败',
        content: `错误信息：${errorMsg}\n\n建议：\n1. 检查云函数是否部署\n2. 检查网络连接\n3. 查看云函数日志`,
        showCancel: false,
        confirmText: '确定'
      })
    }
  },

  // 测试注册申请功能
  testTeamRegistration() {
    console.log('🧪 测试注册申请功能')

    wx.showModal({
      title: '测试注册申请',
      content: '这将跳转到施工队伍注册页面进行测试',
      confirmText: '确定',
      cancelText: '取消',
      success: (res) => {
        if (res.confirm) {
          wx.navigateTo({
            url: '/pages/team-registration/team-registration?type=individual'
          })
        }
      }
    })
  },

  // 打开审核管理
  openAuditManagement() {
    console.log('🔍 打开审核管理')

    wx.navigateTo({
      url: '/pages/audit-management/audit-management'
    })
  },

  // 查看注册状态
  checkRegistrationStatus() {
    console.log('📋 查看注册状态')

    wx.navigateTo({
      url: '/pages/registration-status/registration-status'
    })
  },

  // 打开通知中心
  openNotifications() {
    console.log('🔔 打开通知中心')

    wx.navigateTo({
      url: '/pages/notifications/notifications'
    })
  },

  // 测试通知功能
  async testNotification() {
    console.log('🧪 测试通知功能')

    wx.showLoading({
      title: '发送测试通知...',
      mask: true
    })

    try {
      const result = await wx.cloud.callFunction({
        name: 'testNotification',
        data: {}
      })

      console.log('🧪 测试通知结果:', result.result)

      if (result.result && result.result.success) {
        wx.showModal({
          title: '测试成功',
          content: `测试通知发送成功！\n通知ID: ${result.result.data.notificationId}\n总通知数: ${result.result.data.totalNotifications}`,
          showCancel: false,
          confirmText: '查看通知',
          success: (res) => {
            if (res.confirm) {
              this.openNotifications()
            }
          }
        })
      } else {
        throw new Error(result.result?.error || '测试失败')
      }

    } catch (error) {
      console.error('❌ 测试通知失败:', error)
      wx.showModal({
        title: '测试失败',
        content: `通知功能测试失败：${error.message}`,
        showCancel: false
      })
    } finally {
      wx.hideLoading()
    }
  },

  // 初始化通知集合
  async initNotifications() {
    console.log('🔔 初始化通知集合')

    wx.showLoading({
      title: '初始化通知中...',
      mask: true
    })

    try {
      const result = await wx.cloud.callFunction({
        name: 'initNotifications',
        data: {}
      })

      console.log('🔔 初始化通知结果:', result.result)

      if (result.result && result.result.success) {
        const data = result.result.data
        wx.showModal({
          title: '初始化成功',
          content: `通知集合初始化完成！\n插入通知: ${data.insertResults.filter(r => r.success).length}条\n总通知数: ${data.totalNotifications}条`,
          showCancel: false,
          confirmText: '查看通知',
          success: (res) => {
            if (res.confirm) {
              this.openNotifications()
            }
          }
        })
      } else {
        throw new Error(result.result?.error || '初始化失败')
      }

    } catch (error) {
      console.error('❌ 初始化通知失败:', error)
      wx.showModal({
        title: '初始化失败',
        content: `通知集合初始化失败：${error.message}`,
        showCancel: false
      })
    } finally {
      wx.hideLoading()
    }
  },

  // 打开登录日志（管理员功能）
  openLoginLogs() {
    console.log('📊 打开登录日志')

    // 检查管理员权限
    if (!this.data.hasAdminPermission) {
      wx.showModal({
        title: '权限不足',
        content: '登录日志是管理员功能，您需要管理员权限才能查看。',
        showCancel: false,
        confirmText: '我知道了'
      })
      return
    }

    wx.navigateTo({
      url: '/pages/login-logs/login-logs'
    })
  },







  // 记录登录日志（个人中心专用）
  async recordLoginLog(loginType, description = '') {
    try {
      console.log(`📝 记录登录日志 - 类型: ${loginType}, 描述: ${description}`)

      const systemInfo = wx.getSystemInfoSync()

      const result = await wx.cloud.callFunction({
        name: 'recordLoginLog',
        data: {
          loginType: loginType,
          deviceInfo: {
            platform: systemInfo.platform || 'unknown',
            system: systemInfo.system || 'unknown',
            version: systemInfo.version || 'unknown',
            model: systemInfo.model || 'unknown',
            brand: systemInfo.brand || 'unknown',
            screenWidth: systemInfo.screenWidth || 0,
            screenHeight: systemInfo.screenHeight || 0,
            pixelRatio: systemInfo.pixelRatio || 1
          },
          locationInfo: {
            province: '',
            city: '',
            country: '中国'
          },
          userInfo: {
            nickName: this.data.userInfo?.nickName || '',
            avatarUrl: this.data.userInfo?.avatarUrl || '',
            gender: this.data.userInfo?.gender || 0,
            language: systemInfo.language || 'zh_CN'
          },
          source: 'profile_action', // 来源：个人中心操作
          description: description // 操作描述
        }
      })

      if (result.result && result.result.success) {
        console.log('✅ 登录日志记录成功:', result.result.data.sessionId)
      } else {
        console.warn('⚠️ 登录日志记录失败:', result.result?.error)
      }

    } catch (error) {
      console.error('❌ 记录登录日志异常:', error)
    }
  },

  // 初始化用户权限角色
  async initUserRoles() {
    console.log('🔐 初始化用户权限角色')

    wx.showLoading({
      title: '初始化中...',
      mask: true
    })

    try {
      const result = await wx.cloud.callFunction({
        name: 'initUserRoles',
        data: {}
      })

      console.log('🔐 初始化权限角色结果:', result.result)

      if (result.result && result.result.success) {
        const data = result.result.data
        // 初始化成功后重新检查权限
        setTimeout(() => {
          this.checkUserPermissions()
        }, 1000)

        wx.showModal({
          title: '初始化成功',
          content: `权限角色初始化完成！\n创建角色: ${data.rolesCreated}个\n${data.currentUserSetAsAdmin ? '您已被设置为超级管理员' : '角色已存在'}\n\n管理员菜单将自动显示`,
          showCancel: false,
          confirmText: '查看权限',
          success: (res) => {
            if (res.confirm) {
              this.goToUserPermissions()
            }
          }
        })
      } else {
        throw new Error(result.result?.error || '初始化失败')
      }

    } catch (error) {
      console.error('❌ 初始化权限角色失败:', error)
      wx.showModal({
        title: '初始化失败',
        content: `权限角色初始化失败：${error.message}`,
        showCancel: false
      })
    } finally {
      wx.hideLoading()
    }
  },

  // 测试权限功能
  async testPermissionFunction() {
    console.log('🧪 测试权限功能')

    wx.showLoading({
      title: '测试中...',
      mask: true
    })

    try {
      // 测试权限检查
      const adminCheck = await checkPermission(PERMISSIONS.ADMIN)
      const userMgmtCheck = await checkPermission(PERMISSIONS.USER_MANAGEMENT)
      const auditCheck = await checkPermission(PERMISSIONS.AUDIT_MANAGEMENT)

      // 获取用户权限信息
      const permissionResult = await wx.cloud.callFunction({
        name: 'checkUserPermission',
        data: { permission: 'basic' }
      })

      let userInfo = {}
      if (permissionResult.result && permissionResult.result.success) {
        userInfo = permissionResult.result.data
      }

      wx.showModal({
        title: '权限测试结果',
        content: `管理员权限: ${adminCheck ? '✅' : '❌'}\n用户管理: ${userMgmtCheck ? '✅' : '❌'}\n审核管理: ${auditCheck ? '✅' : '❌'}\n\n当前角色: ${userInfo.roleName || '未知'}\n权限数量: ${userInfo.permissions?.length || 0}`,
        showCancel: false,
        confirmText: '查看详情',
        success: (res) => {
          if (res.confirm) {
            console.log('🔍 详细权限信息:', userInfo)
          }
        }
      })

    } catch (error) {
      console.error('❌ 权限功能测试失败:', error)
      wx.showModal({
        title: '测试失败',
        content: `权限功能测试失败：${error.message}`,
        showCancel: false
      })
    } finally {
      wx.hideLoading()
    }
  },

  // 刷新权限状态
  async refreshPermissions() {
    console.log('🔄 手动刷新权限状态')

    wx.showLoading({
      title: '刷新权限中...',
      mask: true
    })

    try {
      // 强制重新检查权限
      await this.checkUserPermissions()

      const { hasAdminPermission, userPermissions, userRole } = this.data

      wx.showModal({
        title: '权限状态已刷新',
        content: `管理员权限: ${hasAdminPermission ? '✅ 有' : '❌ 无'}\n用户角色: ${userRole}\n权限列表: ${userPermissions.join(', ')}\n\n管理员菜单: ${hasAdminPermission ? '应该已显示' : '需要管理员权限'}`,
        showCancel: false,
        confirmText: '好的'
      })

      // 如果有管理员权限但菜单没显示，强制刷新页面数据
      if (hasAdminPermission) {
        console.log('✅ 检测到管理员权限，菜单应该显示')
        // 强制更新页面数据
        this.setData({
          hasAdminPermission: true,
          userPermissions: userPermissions,
          userRole: userRole
        })
      }

    } catch (error) {
      console.error('❌ 刷新权限状态失败:', error)
      wx.showModal({
        title: '刷新失败',
        content: `权限状态刷新失败：${error.message}`,
        showCancel: false
      })
    } finally {
      wx.hideLoading()
    }
  },

  // 强制启用管理员菜单
  forceEnableAdminMenu() {
    console.log('🔧 强制启用管理员菜单')

    wx.showModal({
      title: '强制启用管理员菜单',
      content: '这将强制设置hasAdminPermission为true，仅用于调试。确定要继续吗？',
      success: (res) => {
        if (res.confirm) {
          this.setData({
            hasAdminPermission: true
          })

          wx.showToast({
            title: '管理员菜单已强制启用',
            icon: 'success'
          })

          console.log('✅ 管理员菜单已强制启用')
        }
      }
    })
  },

  // 检查权限数据
  async checkPermissionData() {
    console.log('🔍 检查权限数据')

    wx.showLoading({
      title: '检查权限数据...',
      mask: true
    })

    try {
      // 直接调用云函数获取权限数据
      const result = await wx.cloud.callFunction({
        name: 'checkUserPermission',
        data: { permission: 'basic' }
      })

      console.log('🔍 云函数返回的完整数据:', result)

      if (result.result && result.result.success) {
        const data = result.result.data

        wx.showModal({
          title: '权限数据详情',
          content: `权限数组: ${JSON.stringify(data.permissions)}\n角色: ${data.role}\n角色名称: ${data.roleName}\n\n原始数据:\n${JSON.stringify(data, null, 2)}`,
          showCancel: false,
          confirmText: '复制到控制台'
        })

        console.log('📋 权限数据详情:', data)
        console.log('📋 权限数组类型:', typeof data.permissions)
        console.log('📋 权限数组内容:', data.permissions)
        if (Array.isArray(data.permissions)) {
          data.permissions.forEach((perm, index) => {
            console.log(`📋 权限[${index}]: "${perm}" (类型: ${typeof perm})`)
          })
        }

      } else {
        throw new Error(result.result?.error || '获取权限数据失败')
      }

    } catch (error) {
      console.error('❌ 检查权限数据失败:', error)
      wx.showModal({
        title: '检查失败',
        content: `权限数据检查失败：${error.message}`,
        showCancel: false
      })
    } finally {
      wx.hideLoading()
    }
  },

  // 修复超级管理员权限
  async fixSuperAdminPermissions() {
    console.log('🔧 修复超级管理员权限')

    wx.showLoading({
      title: '修复权限中...',
      mask: true
    })

    try {
      // 调用云函数设置完整的超级管理员权限
      const result = await wx.cloud.callFunction({
        name: 'manageUserPermissions',
        data: {
          action: 'setUserPermissions',
          targetOpenid: null, // null表示当前用户
          permissions: ['super_admin', 'admin', 'user_management', 'audit_management', 'data_management', 'service_management', 'order_management', 'notification_management', 'basic']
        }
      })

      if (result.result && result.result.success) {
        wx.showToast({
          title: '权限修复成功',
          icon: 'success'
        })

        // 延迟刷新权限状态
        setTimeout(() => {
          this.checkUserPermissions()
        }, 1000)

        console.log('✅ 超级管理员权限修复成功')

      } else {
        throw new Error(result.result?.error || '权限修复失败')
      }

    } catch (error) {
      console.error('❌ 修复超级管理员权限失败:', error)
      wx.showModal({
        title: '修复失败',
        content: `权限修复失败：${error.message}`,
        showCancel: false
      })
    } finally {
      wx.hideLoading()
    }
  },

  // 测试权限页面访问
  async testPermissionPageAccess() {
    console.log('🧪 测试权限页面访问')

    const { hasAdminPermission, userRole, userPermissions } = this.data

    wx.showModal({
      title: '权限页面访问测试',
      content: `当前状态:\n管理员权限: ${hasAdminPermission ? '✅ 有' : '❌ 无'}\n用户角色: ${userRole}\n权限列表: ${userPermissions.join(', ')}\n\n是否尝试访问权限管理页面？`,
      success: (res) => {
        if (res.confirm) {
          console.log('🔗 尝试访问权限管理页面')
          this.goToUserPermissions()
        }
      }
    })
  },

  // 紧急修复权限（直接操作数据库）
  async emergencyFixPermissions() {
    console.log('🚨 紧急修复权限')

    wx.showModal({
      title: '紧急修复权限',
      content: '这将直接操作数据库修复您的权限。\n\n注意：这是紧急修复方案，请确认您有数据库操作权限。\n\n是否继续？',
      success: async (res) => {
        if (res.confirm) {
          wx.showLoading({
            title: '修复权限中...',
            mask: true
          })

          try {
            // 直接操作数据库，不通过权限检查
            const db = wx.cloud.database()

            // 获取当前用户的openid
            const { result: userResult } = await wx.cloud.callFunction({
              name: 'checkUserPermission',
              data: { permission: 'basic' }
            })

            if (!userResult.success) {
              throw new Error('无法获取用户信息')
            }

            // 尝试直接更新数据库
            const updateResult = await db.collection('user_permissions')
              .where({
                role: 'super_admin'  // 通过角色查找，避免需要openid
              })
              .update({
                data: {
                  permissions: ['super_admin', 'admin', 'user_management', 'audit_management', 'data_management', 'service_management', 'order_management', 'notification_management', 'basic'],
                  updateTime: new Date()
                }
              })

            console.log('📝 数据库更新结果:', updateResult)

            if (updateResult.stats.updated > 0) {
              wx.showModal({
                title: '修复成功',
                content: `权限修复成功！\n更新了 ${updateResult.stats.updated} 条记录。\n\n请刷新页面查看效果。`,
                showCancel: false,
                confirmText: '刷新权限',
                success: (res) => {
                  if (res.confirm) {
                    this.checkUserPermissions()
                  }
                }
              })
            } else {
              throw new Error('没有找到需要更新的记录')
            }

          } catch (error) {
            console.error('❌ 紧急修复权限失败:', error)

            // 如果直接操作数据库也失败，提供手动修复指导
            wx.showModal({
              title: '修复失败',
              content: `自动修复失败：${error.message}\n\n请手动修复：\n1. 打开云开发控制台\n2. 进入数据库 → user_permissions\n3. 找到您的用户记录\n4. 修改permissions字段\n5. 添加完整的权限数组`,
              showCancel: false,
              confirmText: '我知道了'
            })
          } finally {
            wx.hideLoading()
          }
        }
      }
    })
  },

  // 修复权限数据类型
  async fixPermissionDataType() {
    console.log('🔧 修复权限数据类型')

    wx.showModal({
      title: '修复权限数据类型',
      content: '检测到权限数据可能是字符串格式，需要转换为数组格式。\n\n这将直接操作数据库修复数据类型问题。\n\n是否继续？',
      success: async (res) => {
        if (res.confirm) {
          wx.showLoading({
            title: '修复数据类型中...',
            mask: true
          })

          try {
            const db = wx.cloud.database()

            // 查找所有权限数据为字符串的记录
            const queryResult = await db.collection('user_permissions')
              .where({
                role: 'super_admin'
              })
              .get()

            console.log('📋 查询到的权限记录:', queryResult.data)

            if (queryResult.data.length === 0) {
              throw new Error('没有找到需要修复的记录')
            }

            let fixedCount = 0

            for (const record of queryResult.data) {
              if (typeof record.permissions === 'string') {
                try {
                  // 解析字符串为数组
                  const permissionsArray = JSON.parse(record.permissions)

                  // 更新数据库记录
                  await db.collection('user_permissions')
                    .doc(record._id)
                    .update({
                      data: {
                        permissions: permissionsArray,
                        updateTime: new Date()
                      }
                    })

                  fixedCount++
                  console.log(`✅ 修复记录 ${record._id}:`, permissionsArray)

                } catch (parseError) {
                  console.error(`❌ 解析权限字符串失败 ${record._id}:`, parseError)
                }
              }
            }

            if (fixedCount > 0) {
              wx.showModal({
                title: '修复成功',
                content: `权限数据类型修复成功！\n修复了 ${fixedCount} 条记录。\n\n请刷新权限状态查看效果。`,
                showCancel: false,
                confirmText: '刷新权限',
                success: (res) => {
                  if (res.confirm) {
                    this.checkUserPermissions()
                  }
                }
              })
            } else {
              wx.showModal({
                title: '无需修复',
                content: '没有发现需要修复的权限数据类型问题。',
                showCancel: false
              })
            }

          } catch (error) {
            console.error('❌ 修复权限数据类型失败:', error)
            wx.showModal({
              title: '修复失败',
              content: `数据类型修复失败：${error.message}\n\n请检查数据库权限或手动修复。`,
              showCancel: false
            })
          } finally {
            wx.hideLoading()
          }
        }
      }
    })
  },

  // 强制显示开发工具
  forceShowDevTools() {
    console.log('🔧 强制显示开发工具')

    const { showDevButtons, isSuperAdmin, hasAdminPermission, userRole, userPermissions } = this.data

    console.log('📊 当前状态:', {
      showDevButtons,
      isSuperAdmin,
      hasAdminPermission,
      userRole,
      userPermissions,
      condition1: showDevButtons,
      condition2: isSuperAdmin,
      finalCondition: showDevButtons && isSuperAdmin
    })

    // 强制设置为超级管理员
    this.setData({
      isSuperAdmin: true,
      showDevButtons: true
    })

    wx.showToast({
      title: '开发工具已强制显示',
      icon: 'success'
    })
  },

  // 设置超级管理员状态
  setSuperAdminStatus() {
    console.log('👑 设置超级管理员状态')

    this.setData({
      isSuperAdmin: true,
      hasAdminPermission: true,
      userRole: 'super_admin',
      showDevButtons: true
    })

    console.log('✅ 超级管理员状态已设置:', this.data)

    wx.showToast({
      title: '超级管理员状态已设置',
      icon: 'success'
    })
  },

  // 测试函数
  testFunction() {
    wx.showToast({
      title: '开发工具栏正常工作！',
      icon: 'success'
    })
    console.log('✅ 开发工具栏测试成功')
  },

  // 强制设置超级管理员
  forceSuperAdmin() {
    console.log('👑 强制设置超级管理员')

    this.setData({
      isSuperAdmin: true,
      hasAdminPermission: true,
      userRole: 'super_admin'
    })

    console.log('✅ 强制设置完成:', {
      isSuperAdmin: this.data.isSuperAdmin,
      hasAdminPermission: this.data.hasAdminPermission,
      userRole: this.data.userRole
    })

    wx.showToast({
      title: '超级管理员已设置',
      icon: 'success'
    })
  },

  // 切换开发工具显示
  toggleDevTools() {
    console.log('🔧 切换开发工具显示')

    const newShowDevButtons = !this.data.showDevButtons

    this.setData({
      showDevButtons: newShowDevButtons
    })

    wx.showToast({
      title: newShowDevButtons ? '开发工具已显示' : '开发工具已隐藏',
      icon: 'success'
    })

    console.log('✅ 开发工具显示状态:', newShowDevButtons)
  },

  // 显示调试信息
  showDebugInfo() {
    console.log('🐛 显示调试信息')

    const { hasAdminPermission, isSuperAdmin, userRole, userPermissions, showDevButtons } = this.data

    wx.showModal({
      title: '调试信息',
      content: `管理员权限: ${hasAdminPermission ? '✅' : '❌'}\n超级管理员: ${isSuperAdmin ? '✅' : '❌'}\n用户角色: ${userRole}\n权限列表: ${userPermissions.join(', ')}\n开发工具: ${showDevButtons ? '显示' : '隐藏'}`,
      showCancel: false,
      confirmText: '复制到控制台',
      success: (res) => {
        if (res.confirm) {
          console.log('🐛 完整调试信息:', {
            hasAdminPermission,
            isSuperAdmin,
            userRole,
            userPermissions,
            showDevButtons,
            timestamp: this.formatDateTime(new Date())
          })
        }
      }
    })
  },

  // 清除登录状态
  clearLoginState() {
    console.log('🧹 清除登录状态')

    wx.showModal({
      title: '清除登录状态',
      content: '这将清除本地的登录状态和用户信息，需要重新登录。确定要继续吗？',
      success: (res) => {
        if (res.confirm) {
          // 清除本地存储
          wx.removeStorageSync('userInfo')
          wx.removeStorageSync('isLoggedIn')

          // 更新页面状态
          this.setData({
            userInfo: {},
            isLoggedIn: false,
            avatarLoadError: false
          })

          wx.showToast({
            title: '登录状态已清除',
            icon: 'success'
          })

          console.log('✅ 登录状态已清除')
        }
      }
    })
  },

  // 重置用户数据
  resetUserData() {
    console.log('🔄 重置用户数据')

    wx.showModal({
      title: '重置用户数据',
      content: '这将清除本地登录状态，并模拟首次登录场景。确定要继续吗？',
      success: (res) => {
        if (res.confirm) {
          // 清除所有相关的本地存储
          wx.removeStorageSync('userInfo')
          wx.removeStorageSync('isLoggedIn')
          wx.removeStorageSync('loginReturnUrl')

          // 重置页面状态
          this.setData({
            userInfo: {},
            isLoggedIn: false,
            avatarLoadError: false,
            showWechatForm: false,
            tempAvatarUrl: '',
            tempNickname: ''
          })

          wx.showToast({
            title: '用户数据已重置',
            icon: 'success'
          })

          console.log('✅ 用户数据已重置，模拟首次登录状态')
        }
      }
    })
  },

  // 显示待审核队伍数量
  async showPendingTeamsCount() {
    wx.showLoading({
      title: '查询中...'
    })

    try {
      const result = await wx.cloud.callFunction({
        name: 'getPendingTeams',
        data: {
          page: 1,
          pageSize: 1
        }
      })

      wx.hideLoading()

      if (result.result && result.result.success) {
        const totalCount = result.result.data.pagination.totalCount

        wx.showModal({
          title: '待审核队伍',
          content: `当前有 ${totalCount} 个施工队伍注册申请待审核`,
          showCancel: false,
          confirmText: '知道了'
        })
      } else {
        throw new Error(result.result?.error || '查询失败')
      }

    } catch (error) {
      wx.hideLoading()
      console.error('❌ 查询待审核队伍失败:', error)
      wx.showToast({
        title: '查询失败',
        icon: 'none'
      })
    }
  },

  // 显示开发者菜单（隐藏功能）
  showDeveloperMenu() {
    console.log('🔧 开发者菜单被触发!')

    // 添加轻微震动反馈（仅开发者能感知）
    try {
      wx.vibrateShort()
    } catch (error) {
      // 静默处理震动失败
    }

    // 直接显示菜单
    this.showDeveloperMenuItems()
  },

  // 显示开发者菜单项
  showDeveloperMenuItems() {
    console.log('📋 显示开发者菜单')

    // 使用模态对话框显示菜单选项
    wx.showModal({
      title: '🔧 开发者菜单',
      content: '数据初始化工具集合：\n\n• 数据库初始化\n• 服务数据管理\n• 分类数据管理\n• 测试数据清理\n• 集合状态检查\n• 系统工具\n\n点击"选择"开始操作',
      confirmText: '选择',
      cancelText: '取消',
      success: (res) => {
        if (res.confirm) {
          this.showMenuOptions()
        }
      }
    })
  },

  // 显示具体的菜单选项
  showMenuOptions() {
    const options = [
      { key: 'initDB', name: '初始化数据库' },
      { key: 'serviceData', name: '初始化服务数据' },
      { key: 'forceServiceData', name: '强制重新初始化服务数据' },
      { key: 'initCategory', name: '初始化分类数据' },
      { key: 'cleanTestData', name: '清理测试数据' },
      { key: 'checkCollections', name: '检查集合状态' },
      { key: 'clearData', name: '清除本地数据' },
      { key: 'userInfo', name: '查看用户信息' },
      { key: 'fixServiceId', name: '修复订单serviceId关联' },
      { key: 'adminMenu', name: '管理员菜单开关' },
      { key: 'regenId', name: '重新生成用户ID' },
      { key: 'relogin', name: '强制重新登录' }
    ]

    // 如果有返回URL，添加测试跳转选项
    if (this.data.returnUrl) {
      options.push({ key: 'testJump', name: '测试页面跳转' })
    }

    // 使用连续的模态对话框来实现菜单选择
    this.showMenuStep(options, 0)
  },

  // 递归显示菜单选项
  showMenuStep(options, index) {
    if (index >= options.length) {
      wx.showToast({
        title: '已显示所有选项',
        icon: 'none'
      })
      return
    }

    const option = options[index]
    const remainingCount = options.length - index

    wx.showModal({
      title: `选项 ${index + 1}/${options.length}`,
      content: `${option.name}\n\n还有 ${remainingCount - 1} 个选项`,
      confirmText: '执行',
      cancelText: remainingCount > 1 ? '下一个' : '取消',
      success: (res) => {
        if (res.confirm) {
          // 执行选中的操作
          this.executeMenuAction(option.key)
        } else if (remainingCount > 1) {
          // 显示下一个选项
          this.showMenuStep(options, index + 1)
        }
      }
    })
  },

  // 执行菜单操作
  executeMenuAction(actionKey) {
    console.log('🔧 执行开发者操作:', actionKey)

    switch (actionKey) {
      case 'initDB':
        this.initDatabase()
        break
      case 'clearData':
        this.clearLocalData()
        break
      case 'userInfo':
        this.showCloudUserInfo()
        break
      case 'serviceData':
        this.initServiceData()
        break
      case 'forceServiceData':
        this.forceInitServiceData()
        break
      case 'initCategory':
        this.initCategoryData()
        break
      case 'cleanTestData':
        this.cleanTestData()
        break
      case 'checkCollections':
        this.checkCollectionStatus()
        break
      case 'fixServiceId':
        this.fixOrderServiceId()
        break
      case 'adminMenu':
        this.toggleAdminMenu()
        break
      case 'regenId':
        this.regenerateUserId()
        break
      case 'relogin':
        this.forceRelogin()
        break
      case 'testJump':
        if (this.data.returnUrl) {
          console.log('手动测试跳转到:', this.data.returnUrl)
          this.navigateToReturnUrl()
        }
        break
      default:
        wx.showToast({
          title: '未知操作',
          icon: 'none'
        })
    }
  },

  // 简化版开发者菜单
  showSimpleMenu() {
    console.log('🔧 显示简化版开发者菜单')

    wx.showModal({
      title: '🔧 简化菜单',
      content: '选择要执行的操作：\n\n1. 初始化数据库\n2. 清除本地数据\n3. 查看用户信息\n4. 初始化服务数据',
      confirmText: '确定',
      cancelText: '取消',
      success: (res) => {
        if (res.confirm) {
          // 显示简化的选项
          this.showSimpleOptions()
        }
      }
    })
  },

  // 显示简化选项
  showSimpleOptions() {
    const simpleOptions = [
      { key: 'initDB', name: '初始化数据库' },
      { key: 'clearData', name: '清除本地数据' },
      { key: 'userInfo', name: '查看用户信息' },
      { key: 'serviceData', name: '初始化服务数据' }
    ]

    this.showMenuStep(simpleOptions, 0)
  },

  // 初始化服务数据
  async initServiceData() {
    wx.showModal({
      title: '初始化服务数据',
      content: '将初始化中小市场分类下的6项服务项目，是否继续？',
      success: async (res) => {
        if (res.confirm) {
          await this.createSmeServices()
        }
      }
    })
  },

  // 创建中小市场服务项目
  async createSmeServices() {
    wx.showLoading({ title: '初始化中...' })

    try {
      // 中小市场服务项目数据
      const smeServices = [
        {
          title: "企宽延伸",
          description: "为企业提供专业的宽带网络延伸服务，扩展网络覆盖范围，提升网络连接质量",
          category: "sme_market",
          price: 2800,
          unit: "月",
          rating: "4.8",
          badge: "热门",
          tags: ["企业宽带", "网络延伸", "专线服务"],
          image: "https://images.unsplash.com/photo-1558494949-ef010cbdcc31?w=400&h=300&fit=crop",
          features: ["专业网络规划设计", "高速稳定连接", "7x24小时技术支持", "灵活扩展方案"],
          serviceProcess: ["需求分析与现场勘测", "网络方案设计", "设备安装调试", "网络优化测试", "交付使用培训"]
        },
        {
          title: "商宽延伸",
          description: "商业宽带网络延伸解决方案，为商业场所提供高质量网络连接服务",
          category: "sme_market",
          price: 3200,
          unit: "月",
          rating: "4.7",
          badge: "推荐",
          tags: ["商业宽带", "网络覆盖", "高速连接"],
          image: "https://images.unsplash.com/photo-1560472354-b33ff0c44a43?w=400&h=300&fit=crop",
          features: ["商业级网络质量", "多点位覆盖", "负载均衡技术", "实时监控管理"],
          serviceProcess: ["商业需求评估", "网络架构设计", "专业设备部署", "网络性能调优", "运维服务交付"]
        },
        {
          title: "维保服务",
          description: "专业的IT设备维护保养服务，确保企业信息系统稳定运行",
          category: "sme_market",
          price: 1800,
          unit: "月",
          rating: "4.9",
          badge: "优质",
          tags: ["设备维护", "系统保养", "故障排除"],
          image: "https://images.unsplash.com/photo-1581091226825-a6a2a5aee158?w=400&h=300&fit=crop",
          features: ["定期巡检维护", "故障快速响应", "预防性维护", "备件库存管理"],
          serviceProcess: ["设备状态评估", "维护计划制定", "定期保养执行", "故障处理响应", "维护报告提交"]
        },
        {
          title: "e企组网",
          description: "企业级组网解决方案，构建安全高效的企业内部网络环境",
          category: "sme_market",
          price: 5800,
          unit: "套",
          rating: "4.8",
          badge: "专业",
          tags: ["企业组网", "网络安全", "系统集成"],
          image: "https://images.unsplash.com/photo-1558618666-fcd25c85cd64?w=400&h=300&fit=crop",
          features: ["企业级网络架构", "安全防护体系", "统一网络管理", "可扩展设计"],
          serviceProcess: ["网络需求调研", "组网方案设计", "网络设备部署", "安全策略配置", "网络测试验收"]
        },
        {
          title: "e企收银",
          description: "智能收银系统解决方案，提升企业收银效率和客户体验",
          category: "sme_market",
          price: 3600,
          unit: "套",
          rating: "4.6",
          badge: "智能",
          tags: ["智能收银", "支付系统", "数据分析"],
          image: "https://images.unsplash.com/photo-1556742049-0cfed4f6a45d?w=400&h=300&fit=crop",
          features: ["多种支付方式", "实时数据统计", "库存管理集成", "会员系统支持"],
          serviceProcess: ["业务需求分析", "系统方案设计", "软硬件部署", "数据迁移配置", "操作培训交付"]
        },
        {
          title: "云视讯",
          description: "企业级视频会议解决方案，支持高清视频通话和远程协作",
          category: "sme_market",
          price: 2400,
          unit: "月",
          rating: "4.7",
          badge: "高清",
          tags: ["视频会议", "远程协作", "云服务"],
          image: "https://images.unsplash.com/photo-1587825140708-dfaf72ae4b04?w=400&h=300&fit=crop",
          features: ["高清视频通话", "多方会议支持", "屏幕共享功能", "会议录制回放"],
          serviceProcess: ["会议需求评估", "系统部署配置", "用户账号开通", "使用培训指导", "技术支持服务"]
        }
      ]

      // 调用云函数批量创建
      const result = await wx.cloud.callFunction({
        name: 'businessManager',
        data: {
          action: 'batchCreateServices',
          data: {
            services: smeServices
          }
        }
      })

      wx.hideLoading()

      if (result.result && result.result.success) {
        wx.showModal({
          title: '初始化成功 🎉',
          content: `中小市场分类下的 ${smeServices.length} 项服务已成功添加到数据库！\n\n包括：企宽延伸、商宽延伸、维保服务、e企组网、e企收银、云视讯`,
          showCancel: false,
          confirmText: '确定'
        })
        console.log('✅ 中小市场服务项目初始化完成')
      } else {
        throw new Error(result.result?.error || '初始化失败')
      }

    } catch (error) {
      wx.hideLoading()
      console.error('❌ 初始化服务数据失败:', error)
      wx.showModal({
        title: '初始化失败',
        content: `错误信息：${error.message}`,
        showCancel: false,
        confirmText: '确定'
      })
    }
  },

  // 修复订单serviceId关联
  async fixOrderServiceId() {
    wx.showModal({
      title: '修复serviceId关联',
      content: '将检查并修复所有订单的serviceId关联问题，是否继续？',
      success: async (res) => {
        if (res.confirm) {
          await this.performServiceIdFix()
        }
      }
    })
  },

  // 执行serviceId修复
  async performServiceIdFix() {
    wx.showLoading({ title: '修复中...' })

    try {
      // 调用云函数修复serviceId
      const result = await wx.cloud.callFunction({
        name: 'businessManager',
        data: {
          action: 'fixOrderServiceId'
        }
      })

      wx.hideLoading()

      if (result.result && result.result.success) {
        wx.showModal({
          title: '修复完成 🎉',
          content: `${result.result.message}\n\n修复的订单数量: ${result.result.data.fixedCount}`,
          showCancel: false,
          confirmText: '确定'
        })
        console.log('✅ serviceId修复完成:', result.result.data)
      } else {
        throw new Error(result.result?.error || '修复失败')
      }

    } catch (error) {
      wx.hideLoading()
      console.error('❌ 修复serviceId失败:', error)
      wx.showModal({
        title: '修复失败',
        content: `错误信息：${error.message}`,
        showCancel: false,
        confirmText: '确定'
      })
    }
  },

  // 显示权限状态（调试用）
  async toggleAdminMenu() {
    console.log('🔧 显示权限状态')

    // 重新检查权限
    await this.checkUserPermissions()

    const { hasAdminPermission, userPermissions, userRole } = this.data

    wx.showModal({
      title: '权限状态',
      content: `管理员权限: ${hasAdminPermission ? '✅ 有' : '❌ 无'}\n用户角色: ${userRole}\n权限数量: ${userPermissions.length}\n\n管理员菜单: ${hasAdminPermission ? '已自动显示' : '需要管理员权限'}`,
      showCancel: false,
      confirmText: hasAdminPermission ? '好的' : '初始化权限',
      success: (res) => {
        if (res.confirm && !hasAdminPermission) {
          // 跳转到开发工具区域
          wx.pageScrollTo({
            selector: '.dev-section',
            duration: 300
          })
        }
      }
    })
  },

  // 前往服务管理页面
  goToServiceAdmin() {
    wx.navigateTo({
      url: '/pages/service-admin/service-admin'
    })
  },

  // 前往分类管理页面
  goToCategoryAdmin() {
    wx.navigateTo({
      url: '/pages/category-admin/category-admin'
    })
  },

  // 重新生成用户ID
  async regenerateUserId() {
    wx.showLoading({ title: '重新生成用户ID...' })

    try {
      // 先尝试调用用户管理云函数重新登录
      const result = await wx.cloud.callFunction({
        name: 'userManager',
        data: {
          action: 'login',
          userInfo: this.data.userInfo
        }
      })

      if (result.result.success) {
        await this.handleLoginSuccess(result.result)
        wx.hideLoading()
        wx.showToast({
          title: '用户ID生成成功',
          icon: 'success'
        })
      } else {
        throw new Error(result.result.error || '生成失败')
      }
    } catch (error) {
      wx.hideLoading()
      console.error('重新生成用户ID失败:', error)
      wx.showModal({
        title: '生成失败',
        content: error.message || '请检查网络连接和云函数状态',
        showCancel: false
      })
    }
  },

  // 强制重新登录
  async forceRelogin() {
    // 清除本地登录状态
    wx.removeStorageSync('userInfo')
    wx.removeStorageSync('isLoggedIn')
    
    this.setData({
      userInfo: {},
      isLoggedIn: false,
      avatarLoadError: false
    })

    wx.showToast({
      title: '请重新登录',
      icon: 'none'
    })
  },

  // 快速修复用户ID
  async quickFixUserId() {
    wx.showLoading({ title: '正在修复ID...' })

    try {
      // 获取当前用户信息
      const localUser = this.data.userInfo || {}
      
      // 尝试重新登录并分配ID
      const result = await wx.cloud.callFunction({
        name: 'userManager',
        data: {
          action: 'login',
          userInfo: {
            nickName: localUser.nickName || '微信用户',
            avatarUrl: localUser.avatarUrl || ''
          }
        }
      })

      wx.hideLoading()

      if (result.result && result.result.success) {
        const newUserInfo = result.result.userInfo
        
        // 更新本地存储
        wx.setStorageSync('userInfo', newUserInfo)
        wx.setStorageSync('isLoggedIn', true)

        this.setData({
          userInfo: newUserInfo,
          isLoggedIn: true,
          avatarLoadError: false
        })

        if (newUserInfo.numericId) {
          wx.showModal({
            title: '修复成功 ✅',
            content: `您的9位数字ID已分配: ${newUserInfo.numericId}`,
            showCancel: false,
            confirmText: '好的'
          })
        } else {
          // 如果还是没有ID，尝试其他方法
          await this.tryAlternativeIdFix()
        }
      } else {
        throw new Error(result.result?.error || '登录失败')
      }
    } catch (error) {
      wx.hideLoading()
      console.error('快速修复ID失败:', error)
      
      wx.showModal({
        title: '修复失败',
        content: `无法自动修复ID: ${error.message}\n\n请尝试以下方案:\n1. 检查网络连接\n2. 重新部署云函数\n3. 使用调试工具`,
        showCancel: true,
        cancelText: '稍后再试',
        confirmText: '查看详情',
        success: (res) => {
          if (res.confirm) {
            this.showDetailedDiagnosis()
          }
        }
      })
    }
  },

  // 尝试备用ID修复方法
  async tryAlternativeIdFix() {
    try {
      // 先检查云端是否有用户信息
      const getUserResult = await wx.cloud.callFunction({
        name: 'userManager',
        data: {
          action: 'getUserInfo'
        }
      })

      if (getUserResult.result.success && getUserResult.result.userInfo.numericId) {
        // 云端有ID，同步到本地
        const cloudUser = getUserResult.result.userInfo
        const updatedUser = { ...this.data.userInfo, ...cloudUser }
        
        wx.setStorageSync('userInfo', updatedUser)
        this.setData({ userInfo: updatedUser })

        wx.showToast({
          title: `ID同步成功: ${cloudUser.numericId}`,
          icon: 'success'
        })
      } else {
        // 云端也没有ID，可能是云函数问题
        wx.showModal({
          title: '需要手动处理',
          content: '检测到云函数可能未正确部署或数据库问题。\n\n建议:\n1. 重新部署userManager云函数\n2. 检查数据库权限设置\n3. 联系技术支持',
          showCancel: false
        })
      }
    } catch (error) {
      console.error('备用修复方法失败:', error)
    }
  },

  // 显示详细诊断信息
  showDetailedDiagnosis() {
    const localUser = this.data.userInfo || {}
    
    let message = '🔍 诊断信息:\n\n'
    message += `登录状态: ${this.data.isLoggedIn ? '✅ 已登录' : '❌ 未登录'}\n`
    message += `用户昵称: ${localUser.nickName || '❌ 未设置'}\n`
    message += `9位数字ID: ${localUser.numericId || '❌ 未分配'}\n`
    message += `系统用户ID: ${localUser.userId || '❌ 未分配'}\n`
    message += `OpenID: ${localUser.openid ? '✅ 已设置' : '❌ 未设置'}\n\n`
    message += '🛠️ 建议操作:\n'
    message += '1. 在微信开发者工具控制台运行调试脚本\n'
    message += '2. 检查云函数部署状态\n'
    message += '3. 重新部署userManager云函数'

    wx.showModal({
      title: '详细诊断',
      content: message,
      showCancel: true,
      cancelText: '关闭',
      confirmText: '复制',
      success: (res) => {
        if (res.confirm) {
          wx.setClipboardData({
            data: 'diagnoseUserIdIssue()',
            success: () => {
              wx.showToast({
                title: '已复制到剪贴板',
                icon: 'success'
              })
            }
          })
        }
      }
    })
  },

  // 清除本地数据
  clearLocalData() {
    wx.showModal({
      title: '清除本地数据',
      content: '确定要清除所有本地存储的数据吗？',
      success: (res) => {
        if (res.confirm) {
          wx.clearStorageSync()
          this.setData({
            userInfo: {},
            isLoggedIn: false,
            avatarLoadError: false,
            showWechatForm: false,
            tempAvatarUrl: '',
            tempNickname: '',
            stats: {
              totalOrders: 0,
              activeProjects: 0,
              completedProjects: 0,
              completionRate: 0
            }
          })
          wx.showToast({
            title: '本地数据已清除',
            icon: 'success'
          })

          // 提示用户重新登录
          setTimeout(() => {
            wx.showModal({
              title: '需要重新登录',
              content: '本地数据已清除，请重新登录以恢复您的账户信息。',
              showCancel: false,
              confirmText: '立即登录',
              success: (modalRes) => {
                if (modalRes.confirm) {
                  this.quickLogin()
                }
              }
            })
          }, 1500)
        }
      }
    })
  },

  // 查看云端用户信息
  async showCloudUserInfo() {
    wx.showLoading({ title: '获取云端信息...' })

    try {
      const result = await wx.cloud.callFunction({
        name: 'userManager',
        data: {
          action: 'getUserInfo'
        }
      })

      wx.hideLoading()

      if (result.result.success) {
        const cloudUserInfo = result.result.userInfo
        const localUserInfo = this.data.userInfo

        let message = '📱 本地用户信息:\n'
        message += `昵称: ${localUserInfo.nickName || '无'}\n`
        message += `9位数字ID: ${localUserInfo.numericId || '无'}\n`
        message += `用户编号: ${localUserInfo.displayId || '无'}\n`
        message += `用户ID: ${localUserInfo.userId || '无'}\n`
        message += `OpenID: ${localUserInfo.openid || '无'}\n`
        message += `登录状态: ${this.data.isLoggedIn ? '已登录' : '未登录'}\n\n`

        message += '☁️ 云端用户信息:\n'
        message += `昵称: ${cloudUserInfo.nickName || '无'}\n`
        message += `9位数字ID: ${cloudUserInfo.numericId || '无'}\n`
        message += `用户编号: ${cloudUserInfo.displayId || '无'}\n`
        message += `用户ID: ${cloudUserInfo.userId || '无'}\n`
        message += `数字编号: ${cloudUserInfo.userNumber || '无'}\n`
        message += `OpenID: ${cloudUserInfo.openid || '无'}\n`
        message += `登录次数: ${cloudUserInfo.loginCount || 0}\n`
        message += `等级: ${cloudUserInfo.level || '无'}\n`
        message += `积分: ${cloudUserInfo.points || 0}`

        wx.showModal({
          title: '用户信息对比',
          content: message,
          showCancel: true,
          cancelText: '关闭',
          confirmText: '同步',
          success: (res) => {
            if (res.confirm) {
              this.syncCloudUserInfo(cloudUserInfo)
            }
          }
        })
      } else {
        wx.showModal({
          title: '获取失败',
          content: result.result.error || '无法获取云端用户信息',
          showCancel: false
        })
      }
    } catch (error) {
      wx.hideLoading()
      console.error('获取云端用户信息失败:', error)
      wx.showModal({
        title: '获取失败',
        content: '网络错误或云函数异常: ' + error.message,
        showCancel: false
      })
    }
  },

  // 同步云端用户信息
  syncCloudUserInfo(cloudUserInfo) {
    const updatedUserInfo = {
      ...this.data.userInfo,
      ...cloudUserInfo
    }

    wx.setStorageSync('userInfo', updatedUserInfo)
    
    this.setData({
      userInfo: updatedUserInfo,
      avatarLoadError: false
    })

    wx.showToast({
      title: '信息同步成功',
      icon: 'success'
    })
  },

  // 测试云函数
  async testCloudFunction() {
    wx.showActionSheet({
      itemList: ['测试用户管理', '测试ID生成', '测试数据库连接'],
      success: async (res) => {
        switch (res.tapIndex) {
          case 0:
            await this.testUserManager()
            break
          case 1:
            await this.testIdGeneration()
            break
          case 2:
            await this.testDatabaseConnection()
            break
        }
      }
    })
  },

  // 测试用户管理云函数
  async testUserManager() {
    wx.showLoading({ title: '测试用户管理...' })

    try {
      const result = await wx.cloud.callFunction({
        name: 'userManager',
        data: {
          action: 'getUserInfo'
        }
      })

      wx.hideLoading()

      let message = '📋 用户管理云函数测试结果:\n\n'
      message += `调用成功: ${result.result ? '✅' : '❌'}\n`
      message += `返回状态: ${result.result.success ? '成功' : '失败'}\n`

      if (result.result.success) {
        const userInfo = result.result.userInfo
        message += `\n👤 用户信息:\n`
        message += `昵称: ${userInfo.nickName || '无'}\n`
        message += `用户ID: ${userInfo.userId || '❌ 未分配'}\n`
        message += `用户编号: ${userInfo.displayId || '❌ 未分配'}\n`
        message += `数字编号: ${userInfo.userNumber || '❌ 未分配'}\n`
        message += `OpenID: ${userInfo.openid ? '✅ 已设置' : '❌ 未设置'}\n`
        message += `登录次数: ${userInfo.loginCount || 0}\n`
      } else {
        message += `错误信息: ${result.result.error}\n`
      }

      wx.showModal({
        title: '测试结果',
        content: message,
        showCancel: false
      })

    } catch (error) {
      wx.hideLoading()
      wx.showModal({
        title: '测试失败',
        content: `云函数调用失败: ${error.message}`,
        showCancel: false
      })
    }
  },

  // 测试ID生成
  async testIdGeneration() {
    wx.showActionSheet({
      itemList: ['生成新ID（测试）', '调试当前用户信息', '检查ID分配状态'],
      success: async (res) => {
        switch (res.tapIndex) {
          case 0:
            await this.testGenerateNewId()
            break
          case 1:
            await this.debugCurrentUser()
            break
          case 2:
            await this.checkIdAssignmentStatus()
            break
        }
      }
    })
  },

  // 测试生成新ID
  async testGenerateNewId() {
    wx.showLoading({ title: '测试ID生成...' })

    try {
      const result = await wx.cloud.callFunction({
        name: 'userManager',
        data: {
          action: 'generateUserId'
        }
      })

      wx.hideLoading()

      let message = '🆔 ID生成测试结果:\n\n'
      message += `调用成功: ${result.result ? '✅' : '❌'}\n`

      if (result.result && result.result.success) {
        message += `生成状态: ✅ 成功\n\n`
        message += `🎯 生成的ID信息:\n`
        message += `用户ID: ${result.result.userId}\n`
        message += `数字编号: ${result.result.userNumber}\n`
        message += `显示编号: ${result.result.displayId}\n`
      } else {
        message += `生成状态: ❌ 失败\n`
        message += `错误信息: ${result.result?.error || '未知错误'}\n`
      }

      wx.showModal({
        title: 'ID生成测试',
        content: message,
        showCancel: false
      })

    } catch (error) {
      wx.hideLoading()
      wx.showModal({
        title: '测试失败',
        content: `ID生成测试失败: ${error.message}`,
        showCancel: false
      })
    }
  },

  // 调试当前用户信息
  async debugCurrentUser() {
    wx.showLoading({ title: '调试用户信息...' })

    try {
      const result = await wx.cloud.callFunction({
        name: 'userManager',
        data: {
          action: 'debugUserInfo'
        }
      })

      wx.hideLoading()

      if (result.result.success) {
        const debug = result.result.debugInfo
        let message = '🔍 用户信息调试结果:\n\n'
        message += `OpenID: ${debug.openid ? '✅ 已设置' : '❌ 未设置'}\n`
        message += `用户存在: ${debug.userExists ? '✅ 是' : '❌ 否'}\n`
        message += `记录数量: ${debug.userCount}\n`
        message += `数据库总用户: ${debug.totalUsers}\n\n`

        if (debug.userExists && debug.userInfo) {
          const user = debug.userInfo
          message += `📋 用户详细信息:\n`
          message += `昵称: ${user.nickName}\n`
          message += `9位数字ID: ${user.numericId}\n`
          message += `用户ID: ${user.userId}\n`
          message += `数字编号: ${user.userNumber}\n`
          message += `显示编号: ${user.displayId}\n`
          message += `登录次数: ${user.loginCount}\n`
          message += `完整ID: ${debug.hasAllIds ? '✅ 是' : '❌ 否'}\n`
        }

        wx.showModal({
          title: '调试结果',
          content: message,
          showCancel: false
        })
      } else {
        wx.showModal({
          title: '调试失败',
          content: result.result.error || '无法获取调试信息',
          showCancel: false
        })
      }

    } catch (error) {
      wx.hideLoading()
      wx.showModal({
        title: '调试失败',
        content: `调试失败: ${error.message}`,
        showCancel: false
      })
    }
  },

  // 检查ID分配状态
  async checkIdAssignmentStatus() {
    wx.showLoading({ title: '检查ID状态...' })

    const localUserInfo = this.data.userInfo
    let message = '📊 ID分配状态检查:\n\n'

    // 检查本地存储
    message += `📱 本地存储状态:\n`
    message += `登录状态: ${this.data.isLoggedIn ? '✅ 已登录' : '❌ 未登录'}\n`
    message += `用户昵称: ${localUserInfo.nickName || '❌ 未设置'}\n`
    message += `9位数字ID: ${localUserInfo.numericId || '❌ 未分配'}\n`
    message += `用户ID: ${localUserInfo.userId || '❌ 未分配'}\n`
    message += `用户编号: ${localUserInfo.displayId || '❌ 未分配'}\n`
    message += `OpenID: ${localUserInfo.openid ? '✅ 已设置' : '❌ 未设置'}\n\n`

    try {
      // 检查云端状态
      const result = await wx.cloud.callFunction({
        name: 'userManager',
        data: {
          action: 'getUserInfo'
        }
      })

      wx.hideLoading()

      if (result.result.success) {
        const cloudUser = result.result.userInfo
        message += `☁️ 云端状态:\n`
        message += `用户存在: ✅ 是\n`
        message += `9位数字ID: ${cloudUser.numericId || '❌ 未分配'}\n`
        message += `用户ID: ${cloudUser.userId || '❌ 未分配'}\n`
        message += `用户编号: ${cloudUser.displayId || '❌ 未分配'}\n`
        message += `登录次数: ${cloudUser.loginCount || 0}\n\n`

        // 对比分析
        message += `🔄 同步状态:\n`
        const localHasId = !!(localUserInfo.numericId)
        const cloudHasId = !!(cloudUser.numericId)
        
        if (cloudHasId && !localHasId) {
          message += `状态: 🔄 需要同步\n`
          message += `建议: 点击"同步云端信息"`
        } else if (!cloudHasId) {
          message += `状态: ❌ 云端未分配ID\n`
          message += `建议: 点击"重新生成ID"`
        } else if (localHasId && cloudHasId) {
          message += `状态: ✅ 已同步\n`
        } else {
          message += `状态: ❓ 需要重新登录\n`
          message += `建议: 点击"强制重新登录"`
        }
      } else {
        message += `☁️ 云端状态: ❌ 获取失败\n`
        message += `错误: ${result.result.error}\n`
      }

      wx.showModal({
        title: 'ID状态检查',
        content: message,
        showCancel: true,
        cancelText: '关闭',
        confirmText: '修复问题',
        success: (res) => {
          if (res.confirm) {
            this.showFixOptions()
          }
        }
      })

    } catch (error) {
      wx.hideLoading()
      message += `☁️ 云端检查: ❌ 失败\n`
      message += `错误: ${error.message}`

      wx.showModal({
        title: 'ID状态检查',
        content: message,
        showCancel: false
      })
    }
  },

  // 显示修复选项
  showFixOptions() {
    wx.showActionSheet({
      itemList: ['重新生成ID', '同步云端信息', '强制重新登录', '清除缓存重置'],
      success: async (res) => {
        switch (res.tapIndex) {
          case 0:
            await this.regenerateUserId()
            break
          case 1:
            await this.showCloudUserInfo()
            break
          case 2:
            await this.forceRelogin()
            break
          case 3:
            this.clearLocalData()
            break
        }
      }
    })
  },

  // 复制用户ID
  copyUserId() {
    const userInfo = this.data.userInfo
    if (!userInfo || !userInfo.numericId) {
      wx.showToast({
        title: '暂无可复制的ID',
        icon: 'none'
      })
      return
    }

    wx.setClipboardData({
      data: userInfo.numericId,
      success: () => {
        // 显示复制成功的反馈
        wx.showToast({
          title: '已复制到剪贴板',
          icon: 'success',
          duration: 1500
        })

        // 添加震动反馈
        wx.vibrateShort({
          type: 'light'
        })

        // 临时改变图标显示复制成功状态
        this.showCopySuccess()
      },
      fail: (err) => {
        console.error('复制失败:', err)
        wx.showToast({
          title: '复制失败',
          icon: 'none'
        })
      }
    })
  },

  // 显示复制成功状态
  showCopySuccess() {
    // 可以在这里添加临时的视觉反馈
    // 比如改变图标或颜色，1秒后恢复
    const originalData = this.data.userInfo
    this.setData({
      copySuccess: true
    })

    setTimeout(() => {
      this.setData({
        copySuccess: false
      })
    }, 1000)
  },

  // 长按显示ID相关选项
  showIdOptions() {
    const userInfo = this.data.userInfo
    if (!userInfo || !userInfo.numericId) {
      return
    }

    wx.showActionSheet({
      itemList: ['复制匠心号', '分享匠心号', '重新生成ID', '查看ID详情'],
      success: async (res) => {
        switch (res.tapIndex) {
          case 0:
            this.copyUserId()
            break
          case 1:
            this.shareUserId()
            break
          case 2:
            this.regenerateUserId()
            break
          case 3:
            this.showIdDetails()
            break
        }
      }
    })

    // 添加震动反馈
    wx.vibrateShort({
      type: 'medium'
    })
  },

  // 分享用户ID
  shareUserId() {
    const userInfo = this.data.userInfo
    if (!userInfo || !userInfo.numericId) {
      return
    }

    wx.showShareMenu({
      withShareTicket: true,
      menus: ['shareAppMessage', 'shareTimeline']
    })

    // 设置分享内容
    wx.onShareAppMessage(() => {
      return {
        title: `我的匠心号: ${userInfo.numericId}`,
        path: `/pages/index/index?sharedUserId=${userInfo.numericId}`,
        imageUrl: userInfo.avatarUrl || '/images/default-avatar.svg'
      }
    })

    wx.showToast({
      title: '请点击右上角分享',
      icon: 'none'
    })
  },

  // 显示ID详情
  showIdDetails() {
    const userInfo = this.data.userInfo
    if (!userInfo || !userInfo.numericId) {
      return
    }

    let message = '🆔 匠心号详情:\n\n'
    message += `匠心号: ${userInfo.numericId}\n`
    message += `用户昵称: ${userInfo.nickName || '未设置'}\n`
    message += `注册时间: ${userInfo.createTime ? this.formatDateTime(userInfo.createTime) : '未知'}\n`
    message += `登录次数: ${userInfo.loginCount || 0}\n`
    message += `用户等级: ${userInfo.level || 'normal'}\n`
    message += `积分: ${userInfo.points || 0}\n\n`
    message += '💡 匠心号是您在数智匠心工程平台的唯一标识'

    wx.showModal({
      title: '匠心号详情',
      content: message,
      showCancel: true,
      cancelText: '关闭',
      confirmText: '复制详情',
      success: (res) => {
        if (res.confirm) {
          wx.setClipboardData({
            data: message,
            success: () => {
              wx.showToast({
                title: '详情已复制',
                icon: 'success'
              })
            }
          })
        }
      }
    })
  },

  // 测试数据库连接
  async testDatabaseConnection() {
    wx.showLoading({ title: '测试数据库连接...' })

    try {
      const db = wx.cloud.database()
      const result = await db.collection('users').count()

      wx.hideLoading()

      let message = '💾 数据库连接测试结果:\n\n'
      message += `连接状态: ✅ 成功\n`
      message += `用户集合记录数: ${result.total}\n`
      message += `云开发环境: 正常\n`

      wx.showModal({
        title: '数据库测试',
        content: message,
        showCancel: false
      })

    } catch (error) {
      wx.hideLoading()
      wx.showModal({
        title: '测试失败',
        content: `数据库连接失败: ${error.message}`,
        showCancel: false
      })
    }
  },

  // 退出登录
  logout() {
    console.log('🚪 用户点击退出登录')

    wx.showModal({
      title: '退出登录',
      content: '确定要退出登录吗？退出后将无法查看个人订单和项目信息。',
      success: (res) => {
        if (res.confirm) {
          console.log('🚪 用户确认退出登录')

          // 记录退出登录日志
          const currentUser = this.data.userInfo
          this.recordLoginLog('logout', `用户退出登录: ${currentUser.nickName || '未知用户'}`)

          // 清除登录信息
          wx.removeStorageSync('userInfo')
          wx.removeStorageSync('isLoggedIn')

          this.setData({
            userInfo: {},
            isLoggedIn: false,
            avatarLoadError: false,
            stats: {
              totalOrders: 0,
              activeProjects: 0,
              completedProjects: 0,
              completionRate: 0
            }
          })

          wx.showToast({
            title: '已退出登录',
            icon: 'success'
          })
        } else {
          console.log('🚪 用户取消退出登录')

          // 记录取消退出日志
          this.recordLoginLog('logout_cancel', '用户取消退出登录')
        }
      }
    })
  },

  // 显示登录提示
  showLoginTip() {
    wx.showModal({
      title: '需要登录',
      content: '此功能需要登录后才能使用，是否立即使用微信登录？',
      confirmText: '立即登录',
      cancelText: '取消',
      success: (res) => {
        if (res.confirm) {
          this.loginWithWechat()
        }
      }
    })
  },



  // 导航到用户权限管理
  async goToUserPermissions() {
    console.log('🔐 导航到用户权限管理')

    // 使用本地权限状态检查，如果本地显示有管理员权限就直接跳转
    if (this.data.hasAdminPermission) {
      console.log('✅ 本地权限检查通过，直接跳转')
      wx.navigateTo({
        url: '/pages/user-permissions/user-permissions'
      })
      return
    }

    // 如果本地权限状态不准确，重新检查权限
    console.log('🔍 本地权限状态不准确，重新检查权限')
    await this.checkUserPermissions()

    if (this.data.hasAdminPermission) {
      console.log('✅ 重新检查权限通过，跳转')
      wx.navigateTo({
        url: '/pages/user-permissions/user-permissions'
      })
    } else {
      console.log('❌ 权限检查失败')
      wx.showModal({
        title: '权限不足',
        content: '您没有管理员权限，无法访问用户权限管理功能。\n\n当前角色：' + this.data.userRole + '\n权限列表：' + this.data.userPermissions.join(', '),
        showCancel: false
      })
    }
  },

  // 快速分配权限
  async quickAssignPermissions() {
    console.log('⚡ 快速分配权限')

    // 使用本地权限状态检查
    if (!this.data.hasAdminPermission) {
      // 重新检查权限
      await this.checkUserPermissions()

      if (!this.data.hasAdminPermission) {
        wx.showModal({
          title: '权限不足',
          content: '您没有管理员权限，无法分配用户权限。\n\n当前角色：' + this.data.userRole,
          showCancel: false
        })
        return
      }
    }

    wx.showLoading({
      title: '加载用户中...',
      mask: true
    })

    try {
      // 获取未分配权限的用户
      const result = await wx.cloud.callFunction({
        name: 'manageUserPermissions',
        data: {
          action: 'getUnassignedUsers'
        }
      })

      if (result.result && result.result.success) {
        const unassignedUsers = result.result.data

        if (unassignedUsers.length === 0) {
          wx.showModal({
            title: '没有新用户',
            content: '当前没有需要分配权限的新用户。',
            showCancel: false
          })
          return
        }

        // 显示用户选择列表
        const userNames = unassignedUsers.map(user =>
          `${user.nickName || '未知用户'} (${user.openid.substring(0, 8)}...)`
        )

        wx.showActionSheet({
          itemList: userNames,
          success: (res) => {
            const selectedUser = unassignedUsers[res.tapIndex]
            this.showQuickAssignDialog(selectedUser)
          }
        })

      } else {
        throw new Error(result.result?.error || '获取用户列表失败')
      }

    } catch (error) {
      console.error('❌ 快速分配权限失败:', error)
      wx.showModal({
        title: '操作失败',
        content: `无法获取用户列表：${error.message}`,
        showCancel: false
      })
    } finally {
      wx.hideLoading()
    }
  },

  // 显示快速分配权限对话框
  showQuickAssignDialog(user) {
    const roleOptions = ['普通用户', '审核员', '服务管理员', '业务经理', '管理员']

    wx.showActionSheet({
      itemList: roleOptions,
      success: async (res) => {
        const roleMap = ['user', 'auditor', 'service_admin', 'manager', 'admin']
        const selectedRole = roleMap[res.tapIndex]

        await this.assignUserRole(user, selectedRole, roleOptions[res.tapIndex])
      }
    })
  },

  // 分配用户角色
  async assignUserRole(user, roleKey, roleName) {
    wx.showLoading({
      title: '分配权限中...',
      mask: true
    })

    try {
      // 获取角色信息
      const rolesResult = await wx.cloud.callFunction({
        name: 'manageUserPermissions',
        data: {
          action: 'getAllRoles'
        }
      })

      if (!rolesResult.result?.success) {
        throw new Error('获取角色信息失败')
      }

      const role = rolesResult.result.data.find(r => r.roleKey === roleKey)
      if (!role) {
        throw new Error('角色不存在')
      }

      // 分配角色
      const assignResult = await wx.cloud.callFunction({
        name: 'manageUserPermissions',
        data: {
          action: 'setUserRole',
          targetOpenid: user.openid,
          roleId: role._id,
          userInfo: {
            nickName: user.nickName,
            avatarUrl: user.avatarUrl
          }
        }
      })

      if (assignResult.result && assignResult.result.success) {
        wx.showModal({
          title: '分配成功',
          content: `已为用户"${user.nickName || '未知用户'}"分配"${roleName}"权限。`,
          showCancel: false,
          confirmText: '查看详情',
          success: (res) => {
            if (res.confirm) {
              this.goToUserPermissions()
            }
          }
        })

        console.log('✅ 快速权限分配成功:', {
          user: user.nickName,
          role: roleName,
          openid: user.openid
        })

      } else {
        throw new Error(assignResult.result?.error || '分配失败')
      }

    } catch (error) {
      console.error('❌ 分配用户角色失败:', error)
      wx.showModal({
        title: '分配失败',
        content: `权限分配失败：${error.message}`,
        showCancel: false
      })
    } finally {
      wx.hideLoading()
    }
  },

  // 导航功能
  goToOrders() {
    console.log('📋 点击我的订单，当前登录状态:', this.data.isLoggedIn)
    console.log('👤 当前用户信息:', this.data.userInfo)

    if (!this.data.isLoggedIn) {
      console.log('⚠️ 用户未登录，显示登录提示')
      this.showLoginTip()
      return
    }

    console.log('✅ 用户已登录，跳转到订单页面')
    wx.switchTab({
      url: '/pages/orders/orders'
    })
  },

  // 统计项点击事件
  onStatItemTap(e) {
    const { tab } = e.currentTarget.dataset
    console.log('📊 个人中心统计项点击:', tab)
    
    // 检查登录状态
    if (!this.data.isLoggedIn) {
      console.log('⚠️ 用户未登录，显示登录提示')
      this.showLoginTip()
      return
    }
    
    if (tab === 'completion_rate') {
      // 完成率不跳转，只显示提示
      wx.showToast({
        title: '完成率统计',
        icon: 'none',
        duration: 1500
      })
      return
    }
    
    if (tab === 'in_progress') {
      // 进行中包含多个状态，显示选择菜单
      this.showInProgressMenu()
      return
    }
    
    // 其他统计项直接跳转到订单页面对应标签
    // 由于wx.switchTab不支持URL参数，使用全局变量传递
    getApp().globalData.targetTab = tab
    wx.switchTab({
      url: '/pages/orders/orders'
    })
  },

  // 显示进行中状态选择菜单
  showInProgressMenu() {
    const inProgressOptions = [
      { key: 'team_accepted', name: '已接单' },
      { key: 'surveying', name: '查勘中' },
      { key: 'designing', name: '设计中' },
      { key: 'quoted', name: '已报价' },
      { key: 'in_progress', name: '施工中' },
      { key: 'testing', name: '验收中' }
    ]
    
    const itemList = inProgressOptions.map(option => option.name)
    
    wx.showActionSheet({
      itemList: itemList,
      success: (res) => {
        const selectedOption = inProgressOptions[res.tapIndex]
        console.log('📊 选择进行中子状态:', selectedOption)
        
        // 跳转到订单页面对应标签
        // 由于wx.switchTab不支持URL参数，使用全局变量传递
        getApp().globalData.targetTab = selectedOption.key
        wx.switchTab({
          url: '/pages/orders/orders'
        })
      },
      fail: (res) => {
        console.log('用户取消选择')
      }
    })
  },





  goToTools() {
    wx.navigateTo({
      url: '/pages/tools/tools'
    })
  },



  // 处理客服对话
  handleContact(e) {
    console.log('客服对话事件:', e.detail)
    // 这里可以处理客服对话的相关逻辑
    // 例如记录用户进入客服的行为等
  },

  goToAbout() {
    wx.navigateTo({
      url: '/pages/about/about'
    })
  },



  // 联系客服（备用方法）
  contactService() {
    wx.showActionSheet({
      itemList: ['微信客服（推荐）', '查看二维码', '在线咨询', '客服电话'],
      success: (res) => {
        switch (res.tapIndex) {
          case 0:
            this.openWechatCustomerService()
            break
          case 1:
            this.showQRCode()
            break
          case 2:
            this.openOnlineChat()
            break
          case 3:
            this.callCustomerService()
            break
        }
      }
    })
  },

  // 显示客服二维码
  showQRCode() {
    wx.showModal({
      title: '📱 扫码添加客服',
      content: '客服微信号：SmartCraftsman\n\n由于小程序限制，暂时无法显示二维码图片。\n\n添加方式：\n1️⃣ 复制微信号搜索添加\n2️⃣ 让朋友推荐名片\n3️⃣ 拨打客服电话获取二维码\n\n🕒 客服在线时间：9:00-22:00',
      showCancel: true,
      cancelText: '拨打电话',
      confirmText: '复制',
      success: (res) => {
        if (res.confirm) {
          wx.setClipboardData({
            data: 'SmartCraftsman',
            success: () => {
              wx.showToast({
                title: '微信号已复制',
                icon: 'success'
              })
            }
          })
        } else if (res.cancel) {
          this.callCustomerService()
        }
      }
    })
  },

  // 打开微信客服
  openWechatCustomerService() {
    // 直接显示微信客服信息，更可靠的方案
    wx.showModal({
      title: '🤖 微信智能客服',
      content: '客服微信号：SmartCraftsman\n\n🕒 在线时间：9:00-22:00\n📱 扫码或搜索微信号添加\n⚡ 智能回复，秒级响应\n\n💡 添加客服微信获得：\n• 专属服务顾问\n• 项目进度实时通知\n• 优先技术支持',
      showCancel: true,
      cancelText: '稍后添加',
      confirmText: '复制',
      success: (res) => {
        if (res.confirm) {
          wx.setClipboardData({
            data: 'SmartCraftsman',
            success: () => {
              wx.showToast({
                title: '微信号已复制',
                icon: 'success',
                duration: 2000
              })
              // 提示用户下一步操作
              setTimeout(() => {
                wx.showModal({
                  title: '添加客服微信',
                  content: '微信号已复制到剪贴板\n\n请打开微信：\n1️⃣ 点击右上角"+"号\n2️⃣ 选择"添加朋友"\n3️⃣ 粘贴微信号搜索\n4️⃣ 发送验证消息',
                  showCancel: false,
                  confirmText: '知道了'
                })
              }, 1500)
            },
            fail: () => {
              wx.showToast({
                title: '复制失败',
                icon: 'none'
              })
            }
          })
        }
      }
    })
  },

  // 打开在线咨询
  openOnlineChat() {
    wx.showModal({
      title: '💬 多渠道客服',
      content: '🤖 智能客服（推荐）\n微信号：SmartCraftsman\n时间：24小时在线\n\n👨‍💼 人工客服\n电话：400-123-4567\n时间：9:00-18:00\n\n📧 邮件支持\nservice@smartcraft.com\n24小时内回复\n\n💡 微信客服响应最快，推荐优先使用',
      showCancel: true,
      cancelText: '关闭',
      confirmText: '复制',
      success: (res) => {
        if (res.confirm) {
          wx.setClipboardData({
            data: 'SmartCraftsman',
            success: () => {
              wx.showToast({
                title: '微信号已复制',
                icon: 'success',
                duration: 2000
              })
            },
            fail: () => {
              wx.showToast({
                title: '复制失败',
                icon: 'none'
              })
            }
          })
        }
      }
    })
  },

  // 拨打客服电话
  callCustomerService() {
    wx.makePhoneCall({
      phoneNumber: '400-123-4567',
      success: () => {
        console.log('拨打客服电话成功')
      },
      fail: (err) => {
        console.error('拨打电话失败:', err)
        wx.showToast({
          title: '拨打失败',
          icon: 'none'
        })
      }
    })
  },

  // 显示客服选项（备用方法）
  fallbackToWechatId() {
    wx.showModal({
      title: '🤖 联系客服',
      content: '智能客服：\n微信号：SmartCraftsman\n\n人工客服：\n电话：400-123-4567\n时间：9:00-18:00\n\n💡 推荐添加微信号获得更快响应',
      showCancel: true,
      cancelText: '拨打电话',
      confirmText: '复制',
      success: (res) => {
        if (res.confirm) {
          wx.setClipboardData({
            data: 'SmartCraftsman',
            success: () => {
              wx.showToast({
                title: '微信号已复制',
                icon: 'success'
              })
            }
          })
        } else if (res.cancel) {
          this.callCustomerService()
        }
      }
    })
  },



  // 清除缓存
  clearCache() {
    wx.showModal({
      title: '清除缓存',
      content: '确定要清除应用缓存吗？这不会删除您的订单和项目数据。',
      success: (res) => {
        if (res.confirm) {
          // 保留重要数据
          const orders = wx.getStorageSync('orders')
          const projects = wx.getStorageSync('projects')
          const userInfo = wx.getStorageSync('userInfo')

          wx.clearStorageSync()

          // 恢复重要数据
          if (orders) wx.setStorageSync('orders', orders)
          if (projects) wx.setStorageSync('projects', projects)
          if (userInfo) wx.setStorageSync('userInfo', userInfo)

          wx.showToast({
            title: '缓存已清除',
            icon: 'success'
          })
        }
      }
    })
  },

  // ==================== 数据初始化方法（从首页移动过来） ====================

  // 强制重新初始化服务数据
  async forceInitServiceData() {
    wx.showModal({
      title: '确认操作',
      content: '这将删除现有的所有服务数据并重新初始化，包含中小市场等所有分类数据。确定继续吗？',
      success: async (res) => {
        if (res.confirm) {
          wx.showLoading({
            title: '强制重新初始化...'
          })

          try {
            const result = await wx.cloud.callFunction({
              name: 'serviceManager',
              data: {
                action: 'initServiceData',
                force: true
              }
            })

            wx.hideLoading()

            if (result.result.success) {
              wx.showModal({
                title: '重新初始化成功',
                content: `${result.result.message}\n插入了 ${result.result.count} 条服务数据\n\n现在包含中小市场等10个分类的完整数据！`,
                showCancel: false,
                confirmText: '确定'
              })
            } else {
              wx.showModal({
                title: '重新初始化失败',
                content: result.result.error,
                showCancel: false,
                confirmText: '确定'
              })
            }

          } catch (error) {
            wx.hideLoading()
            console.error('强制重新初始化服务数据失败:', error)
            wx.showToast({
              title: '重新初始化失败',
              icon: 'error'
            })
          }
        }
      }
    })
  },

  // 初始化分类数据
  async initCategoryData() {
    wx.showLoading({
      title: '初始化分类数据...',
      mask: true
    })

    try {
      const result = await wx.cloud.callFunction({
        name: 'categoryManager',
        data: {
          action: 'initCategoryData'
        }
      })

      wx.hideLoading()

      if (result.result.success) {
        wx.showToast({
          title: '分类数据初始化成功',
          icon: 'success',
          duration: 2000
        })

        console.log('✅ 分类数据初始化成功:', result.result.message)
      } else {
        wx.showToast({
          title: '初始化失败',
          icon: 'error',
          duration: 2000
        })
        console.error('❌ 分类数据初始化失败:', result.result.error)
      }

    } catch (error) {
      wx.hideLoading()
      wx.showToast({
        title: '初始化失败',
        icon: 'error'
      })
      console.error('❌ 分类数据初始化失败:', error)
    }
  },

  // 清理测试数据
  async cleanTestData() {
    wx.showLoading({
      title: '清理测试数据...'
    })

    try {
      const db = wx.cloud.database()
      const collections = ['users', 'orders', 'projects', 'notifications']
      const results = []

      for (const collectionName of collections) {
        try {
          const result = await db.collection(collectionName).where({
            _test: true
          }).remove()

          console.log(`${collectionName} 集合测试数据清理完成`)
          results.push({ collection: collectionName, success: true, removed: result.stats.removed })
        } catch (error) {
          console.error(`清理 ${collectionName} 集合测试数据失败:`, error)
          results.push({ collection: collectionName, success: false, error: error.message })
        }
      }

      wx.hideLoading()

      let message = '测试数据清理结果:\n\n'
      results.forEach(result => {
        if (result.success) {
          message += `${result.collection}: 清理了 ${result.removed} 条记录\n`
        } else {
          message += `${result.collection}: 清理失败 - ${result.error}\n`
        }
      })

      wx.showModal({
        title: '清理完成',
        content: message,
        showCancel: false
      })

    } catch (error) {
      wx.hideLoading()
      console.error('清理测试数据失败:', error)
      wx.showToast({
        title: '清理失败',
        icon: 'error'
      })
    }
  },

  // 检查集合状态
  async checkCollectionStatus() {
    wx.showLoading({
      title: '检查集合状态...'
    })

    try {
      const db = wx.cloud.database()
      const collections = ['users', 'orders', 'projects', 'notifications', 'services', 'service_categories']
      const results = []

      for (const collectionName of collections) {
        try {
          const countResult = await db.collection(collectionName).count()
          const testDataResult = await db.collection(collectionName).where({
            _test: true
          }).count()

          results.push({
            collection: collectionName,
            success: true,
            total: countResult.total,
            testData: testDataResult.total
          })
        } catch (error) {
          results.push({
            collection: collectionName,
            success: false,
            error: error.message
          })
        }
      }

      wx.hideLoading()

      let message = '数据库集合状态:\n\n'
      results.forEach(result => {
        if (result.success) {
          message += `${result.collection}: ${result.total}条记录 (测试数据: ${result.testData})\n`
        } else {
          message += `${result.collection}: 访问失败 - ${result.error}\n`
        }
      })

      wx.showModal({
        title: '集合状态',
        content: message,
        showCancel: false
      })

    } catch (error) {
      wx.hideLoading()
      console.error('检查集合状态失败:', error)
      wx.showToast({
        title: '检查失败',
        icon: 'error'
      })
    }
  },

  // 检查更新
  async checkUpdate() {
    console.log('🔍 开始检查小程序更新')
    
    try {
      // 显示检查提示
      wx.showLoading({ 
        title: '检查更新中...',
        mask: true
      })

      // 获取更新管理器
      const updateManager = wx.getUpdateManager()
      
      if (!updateManager) {
        wx.hideLoading()
        wx.showModal({
          title: '提示',
          content: '当前微信版本过低，无法使用检查更新功能，请升级微信到最新版本',
          showCancel: false
        })
        return
      }

      // 检查全局状态
      const app = getApp()
      if (app.globalData.updateReady) {
        wx.hideLoading()
        wx.showModal({
          title: '发现新版本',
          content: '新版本已经下载完成，是否立即重启应用以使用新版本？',
          confirmText: '立即重启',
          cancelText: '稍后重启',
          success: (res) => {
            if (res.confirm) {
              console.log('🔄 用户选择立即重启应用')
              updateManager.applyUpdate()
            } else {
              console.log('⏰ 用户选择稍后重启')
              wx.showToast({
                title: '将在下次启动时更新',
                icon: 'none',
                duration: 2000
              })
            }
          }
        })
        return
      }

      if (app.globalData.hasUpdate) {
        wx.hideLoading()
        wx.showModal({
          title: '发现新版本',
          content: '检测到小程序有新版本，新版本正在下载中...',
          showCancel: false,
          confirmText: '好的'
        })
        return
      }

      // 创建新的更新管理器实例进行检查
      let hasUpdateResult = false
      let updateCheckTimeout = null

      // 设置检查超时
      updateCheckTimeout = setTimeout(() => {
        if (!hasUpdateResult) {
          wx.hideLoading()
          wx.showModal({
            title: '检查完成',
            content: '当前已是最新版本',
            showCancel: false,
            confirmText: '确定'
          })
        }
      }, 8000)

      // 设置更新检查结果监听
      updateManager.onCheckForUpdate((res) => {
        hasUpdateResult = true
        if (updateCheckTimeout) {
          clearTimeout(updateCheckTimeout)
        }
        
        wx.hideLoading()
        console.log('📱 手动检查更新结果:', res.hasUpdate)
        
        if (res.hasUpdate) {
          console.log('🎉 发现新版本')
          this.setData({ 
            hasUpdate: true,
            updateStatus: 'downloading'
          })
          wx.showModal({
            title: '发现新版本',
            content: '检测到小程序有新版本，新版本已开始下载...',
            showCancel: false,
            confirmText: '好的'
          })
        } else {
          console.log('✅ 当前已是最新版本')
          this.setData({ 
            hasUpdate: false,
            updateStatus: 'latest'
          })
          wx.showModal({
            title: '检查完成',
            content: '当前已是最新版本',
            showCancel: false,
            confirmText: '确定'
          })
        }
      })

      // 设置新版本下载完成监听
      updateManager.onUpdateReady(() => {
        console.log('📦 新版本下载完成')
        this.setData({ updateStatus: 'ready' })
        
        wx.showModal({
          title: '更新提示',
          content: '新版本已经下载完成，是否立即重启应用以使用新版本？',
          confirmText: '立即重启',
          cancelText: '稍后重启',
          success: (res) => {
            if (res.confirm) {
              console.log('🔄 用户选择立即重启应用')
              updateManager.applyUpdate()
            } else {
              console.log('⏰ 用户选择稍后重启')
              wx.setStorageSync('pendingUpdate', true)
              wx.showToast({
                title: '将在下次启动时更新',
                icon: 'none',
                duration: 2000
              })
            }
          }
        })
      })

      // 设置新版本下载失败监听
      updateManager.onUpdateFailed(() => {
        console.error('❌ 新版本下载失败')
        this.setData({ updateStatus: 'failed' })
        
        wx.showModal({
          title: '更新失败',
          content: '新版本下载失败，请检查网络连接后重试',
          confirmText: '重试',
          cancelText: '取消',
          success: (res) => {
            if (res.confirm) {
              // 用户选择重试，再次检查更新
              setTimeout(() => {
                this.checkUpdate()
              }, 1000)
            }
          }
        })
      })

      // 尝试检查更新（如果之前已经检查过，这里可能不会触发新的检查）
      try {
        updateManager.checkForUpdate()
      } catch (checkError) {
        console.log('⚠️ 无法重复检查更新，使用缓存结果')
        hasUpdateResult = true
        if (updateCheckTimeout) {
          clearTimeout(updateCheckTimeout)
        }
        wx.hideLoading()
        
        // 显示当前状态
        const currentStatus = this.data.updateStatus
        if (currentStatus === 'ready') {
          wx.showModal({
            title: '发现新版本',
            content: '新版本已经下载完成，可以立即更新',
            confirmText: '立即更新',
            cancelText: '稍后更新',
            success: (res) => {
              if (res.confirm) {
                updateManager.applyUpdate()
              }
            }
          })
        } else if (currentStatus === 'downloading') {
          wx.showModal({
            title: '正在下载',
            content: '新版本正在下载中，请稍候...',
            showCancel: false,
            confirmText: '好的'
          })
        } else {
          wx.showModal({
            title: '检查完成',
            content: '当前已是最新版本',
            showCancel: false,
            confirmText: '确定'
          })
        }
      }

    } catch (error) {
      wx.hideLoading()
      console.error('❌ 检查更新过程中出错:', error)
      
      wx.showModal({
        title: '检查失败',
        content: '检查更新时发生错误，请稍后重试',
        showCancel: false,
        confirmText: '确定'
      })
    }
  },

  // 静默检查更新（页面加载时自动执行，不显示加载提示）
  async silentCheckUpdate() {
    console.log('🔍 静默检查小程序更新')
    
    try {
      // 检查全局状态，避免重复检查
      const app = getApp()
      if (app.globalData.updateReady) {
        console.log('📦 全局状态显示更新已准备好')
        this.setData({ 
          hasUpdate: true,
          updateStatus: 'ready'
        })
        return
      }
      
      if (app.globalData.hasUpdate) {
        console.log('📱 全局状态显示有可用更新')
        this.setData({ 
          hasUpdate: true,
          updateStatus: 'downloading'
        })
        return
      }

      if (app.globalData.updateFailed) {
        console.log('❌ 全局状态显示更新失败')
        this.setData({ 
          hasUpdate: false,
          updateStatus: 'failed'
        })
        return
      }

      // 如果全局还没有检查过，等待全局检查完成
      console.log('⏳ 等待全局更新检查完成')
      this.setData({ updateStatus: 'checking' })
      
      // 延迟检查全局状态
      setTimeout(() => {
        const updatedApp = getApp()
        const globalStatus = updatedApp.globalData.updateStatus
        
        if (updatedApp.globalData.updateReady || globalStatus === 'ready') {
          this.setData({ 
            hasUpdate: true,
            updateStatus: 'ready'
          })
        } else if (updatedApp.globalData.hasUpdate || globalStatus === 'downloading') {
          this.setData({ 
            hasUpdate: true,
            updateStatus: 'downloading'
          })
        } else if (updatedApp.globalData.updateFailed || globalStatus === 'failed') {
          this.setData({ 
            hasUpdate: false,
            updateStatus: 'failed'
          })
        } else if (globalStatus === 'latest') {
          this.setData({ 
            hasUpdate: false,
            updateStatus: 'latest'
          })
        } else if (globalStatus === 'unavailable' || globalStatus === 'error') {
          this.setData({ 
            hasUpdate: false,
            updateStatus: 'latest'
          })
        } else {
          // 如果全局检查完成且没有更新
          this.setData({ 
            hasUpdate: false,
            updateStatus: 'latest'
          })
        }
      }, 5000) // 等待5秒让全局检查完成

    } catch (error) {
      console.error('❌ 静默检查更新过程中出错:', error)
      this.setData({ updateStatus: 'failed' })
    }
  },

  // 检查待处理的更新
  checkPendingUpdates() {
    try {
      // 检查是否有待处理的更新
      const pendingUpdate = wx.getStorageSync('pendingUpdate')
      if (pendingUpdate) {
        console.log('📦 检测到待处理的更新')
        wx.removeStorageSync('pendingUpdate')
        
        // 显示更新提示
        setTimeout(() => {
          wx.showModal({
            title: '更新提醒',
            content: '检测到有新版本待更新，建议立即更新以获得最佳体验',
            confirmText: '立即更新',
            cancelText: '稍后更新',
            success: (res) => {
              if (res.confirm) {
                this.checkUpdate()
              }
            }
          })
        }, 1000)
      }

      // 同步全局更新状态
      const app = getApp()
      if (app.globalData.hasUpdate) {
        this.setData({ 
          hasUpdate: true,
          updateStatus: app.globalData.updateReady ? 'ready' : 'downloading'
        })
      } else if (app.globalData.updateFailed) {
        this.setData({ 
          hasUpdate: false,
          updateStatus: 'failed'
        })
      }

    } catch (error) {
      console.error('❌ 检查待处理更新失败:', error)
    }
  },

  // 同步更新状态
  syncUpdateStatus() {
    try {
      const app = getApp()
      
      if (app.globalData.updateReady) {
        this.setData({ 
          hasUpdate: true,
          updateStatus: 'ready'
        })
      } else if (app.globalData.hasUpdate) {
        this.setData({ 
          hasUpdate: true,
          updateStatus: 'downloading'
        })
      } else if (app.globalData.updateFailed) {
        this.setData({ 
          hasUpdate: false,
          updateStatus: 'failed'
        })
      } else {
        // 如果没有全局状态，保持当前状态
        if (this.data.updateStatus === 'none') {
          this.setData({ 
            updateStatus: 'latest'
          })
        }
      }
    } catch (error) {
      console.error('❌ 同步更新状态失败:', error)
    }
  },

  // 获取版本信息
  async loadVersionInfo(silent = false) {
    try {
      if (!silent) {
        console.log('🔄 获取服务器版本信息...')
      }

      const result = await wx.cloud.callFunction({
        name: 'versionManager',
        data: {
          action: 'getCurrentVersion'
        }
      })

      if (result.result && result.result.success) {
        const versionData = result.result.data
        
        // 格式化时间显示
        if (versionData.releaseTime) {
          const releaseDate = new Date(versionData.releaseTime)
          versionData.releaseTime = this.formatDateTime(releaseDate)
        }
        
        this.setData({
          version: versionData.version,
          versionInfo: versionData
        })

        if (!silent) {
          console.log('✅ 版本信息获取成功:', versionData.version)
        }

        // 检查版本兼容性
        await this.checkVersionCompatibility(versionData.version)
      } else {
        console.error('❌ 获取版本信息失败:', result.result?.error)
        // 使用本地默认版本
        this.setData({
          version: '1.0.0',
          versionInfo: {
            version: '1.0.0',
            versionName: '本地版本',
            description: '无法连接服务器，显示本地版本'
          }
        })
      }
    } catch (error) {
      console.error('❌ 版本信息获取异常:', error)
      // 使用本地默认版本
      this.setData({
        version: '1.0.0',
        versionInfo: {
          version: '1.0.0',
          versionName: '本地版本',
          description: '网络异常，显示本地版本'
        }
      })
    }
  },

  // 检查版本兼容性
  async checkVersionCompatibility(serverVersion) {
    try {
      const clientVersion = this.data.version === '加载中...' ? '1.0.0' : this.data.version

      const result = await wx.cloud.callFunction({
        name: 'versionManager',
        data: {
          action: 'checkCompatibility',
          clientVersion: clientVersion
        }
      })

      if (result.result && result.result.success) {
        const compatibilityData = result.result.data
        
        if (compatibilityData.needsUpdate) {
          console.log('📢 发现新版本:', compatibilityData.latestVersion)
          
          // 显示更新提示
          if (compatibilityData.forceUpdate) {
            this.showForceUpdateDialog(compatibilityData)
          } else {
            this.showOptionalUpdateDialog(compatibilityData)
          }
        }
      }
    } catch (error) {
      console.error('❌ 版本兼容性检查失败:', error)
    }
  },

  // 显示强制更新对话框
  showForceUpdateDialog(updateInfo) {
    wx.showModal({
      title: '必须更新',
      content: `发现新版本 ${updateInfo.latestVersion}，需要立即更新才能继续使用。\n\n更新内容：\n${updateInfo.updateInfo.description}`,
      showCancel: false,
      confirmText: '立即更新',
      success: (res) => {
        if (res.confirm) {
          this.performAppUpdate()
        }
      }
    })
  },

  // 显示可选更新对话框
  showOptionalUpdateDialog(updateInfo) {
    wx.showModal({
      title: '发现新版本',
      content: `发现新版本 ${updateInfo.latestVersion}，建议立即更新。\n\n更新内容：\n${updateInfo.updateInfo.description}`,
      confirmText: '立即更新',
      cancelText: '稍后更新',
      success: (res) => {
        if (res.confirm) {
          this.performAppUpdate()
        }
      }
    })
  },

  // 执行应用更新
  performAppUpdate() {
    // 触发小程序更新检查
    this.checkUpdate()
  },

  // 格式化日期时间
  formatDateTime(dateInput) {
    if (!dateInput) return ''
    
    try {
      let date
      
      // 处理不同的日期格式
      if (typeof dateInput === 'string') {
        date = new Date(dateInput)
      } else if (dateInput instanceof Date) {
        date = dateInput
      } else if (typeof dateInput === 'number') {
        date = new Date(dateInput)
      } else {
        date = new Date(String(dateInput))
      }
      
      // 检查日期是否有效
      if (isNaN(date.getTime())) {
        console.warn('❌ 无效的日期格式:', dateInput)
        return String(dateInput)
      }
      
      // 手动格式化，确保兼容性
      const year = date.getFullYear()
      const month = String(date.getMonth() + 1).padStart(2, '0')
      const day = String(date.getDate()).padStart(2, '0')
      const hours = String(date.getHours()).padStart(2, '0')
      const minutes = String(date.getMinutes()).padStart(2, '0')
      
      return `${year}-${month}-${day} ${hours}:${minutes}`
      
    } catch (error) {
      console.error('❌ 格式化日期时间失败:', error, '原始数据:', dateInput)
      return String(dateInput)
    }
  },

  // 显示版本管理面板
  showVersionManager() {
    const versionInfo = this.data.versionInfo || {}
    
    wx.showActionSheet({
      itemList: [
        '查看版本详情',
        '更新版本信息',
        '查看版本历史',
        '强制刷新版本'
      ],
      success: (res) => {
        switch (res.tapIndex) {
          case 0:
            this.showVersionDetails()
            break
          case 1:
            this.showUpdateVersionDialog()
            break
          case 2:
            this.showVersionHistory()
            break
          case 3:
            this.refreshVersionInfo()
            break
        }
      }
    })
  },

  // 显示版本详情
  showVersionDetails(specificVersion = null) {
    const versionInfo = specificVersion || this.data.versionInfo
    if (!versionInfo) {
      wx.showToast({
        title: '版本信息未加载',
        icon: 'none'
      })
      return
    }

    let content = `版本号: ${versionInfo.version}\n`
    if (versionInfo.versionName) content += `版本名: ${versionInfo.versionName}\n`
    if (versionInfo.buildNumber) content += `构建号: ${versionInfo.buildNumber}\n`
    if (versionInfo.releaseTime) {
      const releaseTime = typeof versionInfo.releaseTime === 'string' 
        ? versionInfo.releaseTime 
        : this.formatDateTime(new Date(versionInfo.releaseTime))
      content += `发布时间: ${releaseTime}\n`
    }
    if (versionInfo.description) content += `描述: ${versionInfo.description}\n`
    if (versionInfo.features && versionInfo.features.length > 0) {
      content += `\n新功能:\n${versionInfo.features.map(f => `• ${f}`).join('\n')}`
    }
    if (versionInfo.bugfixes && versionInfo.bugfixes.length > 0) {
      content += `\n修复内容:\n${versionInfo.bugfixes.map(f => `• ${f}`).join('\n')}`
    }

    wx.showModal({
      title: '版本详情',
      content: content,
      showCancel: false,
      confirmText: '确定'
    })
  },

  // 显示更新版本对话框
  showUpdateVersionDialog() {
    wx.showModal({
      title: '更新版本',
      content: '确定要更新版本信息吗？这将创建一个新的版本记录。',
      confirmText: '更新',
      cancelText: '取消',
      success: (res) => {
        if (res.confirm) {
          this.updateVersionInfo()
        }
      }
    })
  },

  // 更新版本信息
  async updateVersionInfo() {
    try {
      wx.showLoading({
        title: '正在更新...',
        mask: true
      })

      // 获取当前版本号并递增
      const currentVersion = this.data.version
      const versionParts = currentVersion.split('.')
      const lastPart = parseInt(versionParts[versionParts.length - 1]) + 1
      versionParts[versionParts.length - 1] = lastPart.toString()
      const newVersion = versionParts.join('.')

      const newVersionData = {
        version: newVersion,
        versionName: '更新版',
        buildNumber: this.generateBuildNumber(),
        releaseTime: new Date(),
        description: `版本 ${newVersion} 更新`,
        features: [
          '版本同步优化',
          '用户体验改进',
          '性能优化'
        ],
        bugfixes: [
          '修复已知问题'
        ],
        minCompatibleVersion: currentVersion,
        forceUpdate: false
      }

      const result = await wx.cloud.callFunction({
        name: 'versionManager',
        data: {
          action: 'updateVersion',
          versionData: newVersionData
        }
      })

      wx.hideLoading()

      if (result.result && result.result.success) {
        wx.showToast({
          title: '版本更新成功',
          icon: 'success'
        })
        
        // 刷新版本信息
        this.loadVersionInfo()
      } else {
        wx.showToast({
          title: '版本更新失败',
          icon: 'none'
        })
      }
    } catch (error) {
      wx.hideLoading()
      console.error('❌ 版本更新失败:', error)
      wx.showToast({
        title: '版本更新异常',
        icon: 'none'
      })
    }
  },

  // 生成构建号
  generateBuildNumber() {
    const now = new Date()
    const year = now.getFullYear()
    const month = String(now.getMonth() + 1).padStart(2, '0')
    const day = String(now.getDate()).padStart(2, '0')
    const hours = String(now.getHours()).padStart(2, '0')
    const minutes = String(now.getMinutes()).padStart(2, '0')
    
    return `${year}${month}${day}${hours}${minutes}`
  },

  // 显示版本历史
  async showVersionHistory() {
    try {
      wx.showLoading({
        title: '加载历史...',
        mask: true
      })

      const result = await wx.cloud.callFunction({
        name: 'versionManager',
        data: {
          action: 'getVersionHistory',
          limit: 5
        }
      })

      wx.hideLoading()

      if (result.result && result.result.success) {
        const versions = result.result.data.versions
        if (versions.length === 0) {
          wx.showToast({
            title: '暂无版本历史',
            icon: 'none'
          })
          return
        }

        const itemList = versions.map(v => 
          `v${v.version} - ${v.versionName || '无名称'} (${this.formatDateTime(new Date(v.releaseTime))})`
        )

        wx.showActionSheet({
          itemList: itemList,
          success: (res) => {
            const selectedVersion = versions[res.tapIndex]
            this.showVersionDetails(selectedVersion)
          }
        })
      } else {
        wx.showToast({
          title: '获取历史失败',
          icon: 'none'
        })
      }
    } catch (error) {
      wx.hideLoading()
      console.error('❌ 获取版本历史失败:', error)
      wx.showToast({
        title: '获取历史异常',
        icon: 'none'
      })
    }
  },

  // 刷新版本信息
  refreshVersionInfo() {
    wx.showToast({
      title: '正在刷新...',
      icon: 'loading'
    })
    
    this.loadVersionInfo()
  },

  // 检查是否为临时头像URL
  isTempAvatarUrl(avatarUrl) {
    if (!avatarUrl) return false
    
    // 检查常见的临时文件路径格式
    const tempPatterns = [
      /^wxfile:\/\/tmp_/,           // 微信临时文件
      /^wxfile:\/\/tmp\//,          // 微信临时目录
      /^http:\/\/tmp_/,             // 临时HTTP路径
      /^file:\/\/\/tmp/,            // 本地临时文件
      /\/tmp_\w+\.(jpg|jpeg|png|gif|webp)$/i,  // 临时文件名模式
      /^data:image\//,              // base64图片数据
      /^blob:/                      // blob URL
    ]
    
    const isTemp = tempPatterns.some(pattern => pattern.test(avatarUrl))
    
    console.log(`🔍 检查头像URL是否为临时文件:`, {
      avatarUrl,
      isTemp,
      patterns: tempPatterns.map(p => p.toString())
    })
    
    return isTemp
  },

  // 上传临时头像到云存储
  async uploadTempAvatarToCloud(tempAvatarUrl) {
    console.log('📤 开始上传临时头像到云存储:', tempAvatarUrl)
    
    try {
      // 显示上传提示（不阻塞用户操作）
      wx.showToast({
        title: '正在同步头像...',
        icon: 'loading',
        duration: 1500,
        mask: false
      })

      // 检查文件是否可访问
      const fileInfo = await this.checkTempFileAccess(tempAvatarUrl)
      if (!fileInfo.accessible) {
        console.log('⚠️ 临时文件不可访问，跳过上传:', fileInfo.error)
        return
      }

      // 上传文件到云存储
      const uploadResult = await this.uploadAvatarToCloud(tempAvatarUrl)
      
      if (uploadResult.success && uploadResult.fileID) {
        console.log('✅ 临时头像上传成功:', uploadResult.fileID)
        
        // 更新数据库中的头像URL
        await this.updateAvatarInDatabase(uploadResult.fileID, '临时文件转云存储')
        
        // 更新本地用户信息
        const userInfo = wx.getStorageSync('userInfo') || {}
        userInfo.avatarUrl = uploadResult.fileID
        wx.setStorageSync('userInfo', userInfo)
        
        // 更新页面显示
        this.setData({
          'userInfo.avatarUrl': uploadResult.fileID
        })
        
        console.log('✅ 头像同步完成，已更新为云存储地址')
        
        // 显示成功提示
        setTimeout(() => {
          wx.showToast({
            title: '头像已同步',
            icon: 'success',
            duration: 1500
          })
        }, 500)
        
      } else {
        console.error('❌ 临时头像上传失败:', uploadResult.error)
      }
      
    } catch (error) {
      console.error('❌ 上传临时头像过程中出错:', error)
      
      // 不显示错误提示给用户，避免影响登录体验
      // 这是一个后台优化功能，失败了也不影响正常使用
    }
  },

  // 检查临时文件访问性
  async checkTempFileAccess(filePath) {
    try {
      // 对于 wxfile:// 开头的路径，尝试获取文件信息
      if (filePath.startsWith('wxfile://')) {
        const fileInfo = await wx.getFileInfo({ filePath })
        console.log('📁 临时文件信息:', fileInfo)
        return { accessible: true, size: fileInfo.size }
      }
      
      // 对于其他格式，假设可访问
      return { accessible: true }
      
    } catch (error) {
      console.log('⚠️ 临时文件访问检查失败:', error)
      return { 
        accessible: false, 
        error: error.errMsg || error.message || '文件不可访问'
      }
    }
  },

  // 更新数据库中的头像URL
  async updateAvatarInDatabase(fileID, source) {
    try {
      const userInfo = wx.getStorageSync('userInfo') || {}
      
      const result = await wx.cloud.callFunction({
        name: 'userManager',
        data: {
          action: 'updateAvatar',
          userId: userInfo.userId,
          avatarUrl: fileID,
          avatarSource: source || '临时文件转云存储',
          updateTime: new Date()
        }
      })
      
      if (result.result.success) {
        console.log('✅ 数据库头像URL更新成功')
        return true
      } else {
        console.error('❌ 数据库头像URL更新失败:', result.result.error)
        return false
      }
      
    } catch (error) {
      console.error('❌ 更新数据库头像URL时出错:', error)
      return false
    }
  }
})